mx_remote_ffi/

subsystems.rs

// Author: Lars Op den Kamp (lars@opdenkamp-it.nl)
// Copyright (c) 2026 Op den Kamp IT Solutions

//! What a device reports about one of its subsystems.
//!
//! These are the values that do not fit in a device or bay snapshot: streams,
//! statistics, the audio tree, the network ports. Each has an event that says
//! it moved and a call here that says what it is now, which is why the events
//! carry only an identifier - what they would carry instead is this, and a
//! copy taken at event time could only be staler than a read.
//!
//! A call returns `MXR_ERR_NOT_REPORTED` when the device exists but has not
//! sent that subsystem, which is a different answer from a device that has
//! never been heard from at all.

use std::ffi::c_char;
use std::net::Ipv4Addr;
use std::time::UNIX_EPOCH;

use mx_remote::{
    AmpDolbySettings, AudioEndpoint, DeviceV2ipDetails, DeviceV2ipSink, FirmwareVersion,
    MultiviewerStatus, NetworkPortStatus, OsdSync, OsdSyncReport, RcSettings, StreamKind,
    TopologyEntry, UnitStatus, UtpCableStatus, V2ipDecoderDetail, V2ipDeviceSettings,
    V2ipDeviceStats, V2ipFpgaFeature, V2ipPrivacy, V2ipPrivacyStream, V2ipPtpMessages,
    V2ipPtpState, V2ipRxStats, V2ipSinkSdp, V2ipStreamSource, V2ipStreamSources, V2ipTestSync,
    V2ipTestTone, V2ipTestcard, V2ipTilingConfig, V2ipToneMode, V2ipTxStats, V2ipVlan, VctStatus,
    MULTIVIEWER_INPUTS, OSD_SYNC_SLOTS,
};

use crate::abi::{fail, guard, mxr_result_t, mxr_uid_t, put_str};
use crate::control::mxr_audio_format_t;
use crate::info::{copy_into, not_heard_from, null_out, MXR_NAME_LEN, MXR_VERSION_LEN};
use crate::remote::{mxr_remote_t, with, MXR_IP_STRING_LEN};

/// How many inputs a multiviewer has.
///
/// Written as a literal because the generated header needs one, and checked
/// against the core crate's value below so the two cannot drift apart.
pub const MXR_MULTIVIEWER_INPUTS: usize = 4;

const _: () = assert!(MXR_MULTIVIEWER_INPUTS == MULTIVIEWER_INPUTS);

/// How many pairs a UTP cable diagnostic covers.
pub const MXR_UTP_PAIRS: usize = 4;

/// Which of a V2IP device's streams an address describes.
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum mxr_stream_kind_t {
    /// The video stream.
    MXR_STREAM_VIDEO = 0,
    /// The audio stream.
    MXR_STREAM_AUDIO = 1,
    /// The ancillary-data stream.
    MXR_STREAM_ANC = 2,
    /// The audio-return stream.
    MXR_STREAM_ARC = 3,
}

impl From<StreamKind> for mxr_stream_kind_t {
    fn from(kind: StreamKind) -> Self {
        match kind {
            StreamKind::Video => Self::MXR_STREAM_VIDEO,
            StreamKind::Audio => Self::MXR_STREAM_AUDIO,
            StreamKind::Anc => Self::MXR_STREAM_ANC,
            StreamKind::Arc => Self::MXR_STREAM_ARC,
        }
    }
}

/// One multicast stream address.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_stream_source_t {
    /// Which stream this address is for.
    pub kind: mxr_stream_kind_t,
    /// The multicast group, as a dotted quad.
    pub ip: [c_char; MXR_IP_STRING_LEN],
    /// The destination UDP port.
    pub port: u16,
    /// Whether this carries a usable address: a multicast group and a non-zero
    /// port, both. A slot a device has not filled in is not an error, so this
    /// is what separates an address from an empty slot.
    pub valid: bool,
}

impl From<V2ipStreamSource> for mxr_stream_source_t {
    fn from(s: V2ipStreamSource) -> Self {
        let mut out = Self {
            kind: s.kind.into(),
            ip: [0; MXR_IP_STRING_LEN],
            port: s.port,
            valid: s.is_valid(),
        };
        put_str(&mut out.ip, &s.ip.to_string());
        out
    }
}

/// The streams one V2IP source advertises.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_stream_sources_t {
    /// The originating device, zero when it is not known.
    pub uid: mxr_uid_t,
    /// The video stream.
    pub video: mxr_stream_source_t,
    /// The audio stream.
    pub audio: mxr_stream_source_t,
    /// The ancillary-data stream.
    pub anc: mxr_stream_source_t,
    /// Whether an audio-return stream is advertised.
    pub has_arc: bool,
    /// The audio-return stream, meaningful only when `has_arc` is set.
    pub arc: mxr_stream_source_t,
}

impl From<V2ipStreamSources> for mxr_stream_sources_t {
    fn from(s: V2ipStreamSources) -> Self {
        Self {
            uid: s.uid.into(),
            video: s.video.into(),
            audio: s.audio.into(),
            anc: s.anc.into(),
            has_arc: s.arc.is_some(),
            arc: s.arc.unwrap_or_default().into(),
        }
    }
}

/// A V2IP device's own encoder configuration.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_details_t {
    /// The video stream this device sources.
    pub video: mxr_stream_source_t,
    /// The audio stream this device sources.
    pub audio: mxr_stream_source_t,
    /// The ancillary-data stream this device sources.
    pub anc: mxr_stream_source_t,
    /// The audio-return stream this device sources.
    pub arc: mxr_stream_source_t,
    /// Encoder rate in units of 10Mb/s, or -1 when no rate has been reported.
    pub tx_rate: i16,
    /// DSCP marking for the video stream, or -1 when unmarked.
    pub dscp_video: i16,
    /// DSCP marking for the audio stream, or -1 when unmarked.
    pub dscp_audio: i16,
    /// DSCP marking for the ancillary-data stream, or -1 when unmarked.
    pub dscp_anc: i16,
    /// The signal type the output scales to.
    pub scaling_mode: u16,
    /// Refresh rate in Hz.
    pub scaling_refresh: u16,
    /// `MXR_SCALING_FLAG_*` bits. Bits outside those are undefined and are not
    /// reliably zero: firmware predating the fix builds this frame over an
    /// uninitialised stack local.
    pub scaling_flags: u8,
}

/// Set when the frame carries a scaling mode and refresh rate.
pub const MXR_SCALING_FLAG_MODE_VALID: u8 = 1 << 0;
/// Set when the frame carries the scaling options.
pub const MXR_SCALING_FLAG_OPTIONS_VALID: u8 = 1 << 1;
/// Set when the frame carries the second group of scaling options.
///
/// Firmware with those options sets this on every configuration it sends about
/// itself, so it doubles as the report that the device has them at all. It is
/// read only from a sender that says it initialises its configuration: on one
/// that does not, this bit is uninitialised stack and the settings behind it
/// would be invented rather than misread.
pub const MXR_SCALING_FLAG_OPTIONS2_VALID: u8 = 1 << 4;
/// Set when the output follows its source's format instead of a fixed one.
pub const MXR_SCALING_FLAG_MATCH_SOURCE: u8 = 1 << 5;
/// Set when the output declines 4:2:0 rather than scaling it.
pub const MXR_SCALING_FLAG_SKIP_420: u8 = 1 << 6;
/// Set when the output scales automatically.
pub const MXR_SCALING_FLAG_AUTO_SCALING: u8 = 1 << 7;

/// The streams a V2IP sink is subscribed to.
///
/// **Addresses that read as unset mean "no route, or the sink could not work
/// one out" - never "definitely not subscribed".** This is the one part of a
/// device configuration with no validity marker of its own, so a sender with
/// nothing to say sends zeros and every receiver stores them. A sender leaves
/// it empty whenever its own stream configuration does not resolve, which
/// covers more than having no route: a selected source whose record has not
/// arrived yet, the state after a restart at either end, missing audio bay
/// configuration, or a stream failing its validity check.
///
/// Expect it rather than guard against it. Any scaling change makes the device
/// rebuild and rebroadcast this block - so the empty reading turns up most
/// often during exactly the no-signal troubleshooting that prompted the change.
/// A device's periodic report puts a real route back within a minute of it
/// having one, so a reader that needs certainty should wait one out rather than
/// treat the first empty reading as an answer.
///
/// Only the device's own report sets this. A controller writing another
/// device's configuration sends the block zeroed, and that frame is ignored.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_sink_t {
    /// The streams the sink subscribes to.
    pub addresses: mxr_stream_sources_t,
    /// Whether the sender reported a resolved audio format.
    pub has_audio_format: bool,
    /// The audio format, meaningful only when `has_audio_format` is set.
    pub audio_format: mxr_audio_format_t,
}

/// Transmitter stream statistics.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_tx_stats_t {
    /// Video packets sent.
    pub video: u32,
    /// Audio packets sent.
    pub audio: u32,
    /// Ancillary-data packets sent.
    pub anc: u32,
    /// Times the stream went down.
    pub stream_down: u32,
    /// Transmit overflows.
    pub overflow: u32,
}

impl From<V2ipTxStats> for mxr_v2ip_tx_stats_t {
    fn from(s: V2ipTxStats) -> Self {
        Self {
            video: s.video,
            audio: s.audio,
            anc: s.anc,
            stream_down: s.stream_down,
            overflow: s.overflow,
        }
    }
}

/// Receiver stream statistics.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_rx_stats_t {
    /// Video packets received.
    pub video_total: u32,
    /// Video packets dropped.
    pub video_dropped: u32,
    /// Video sequence errors.
    pub video_seq_errors: u32,
    /// Watchdog timeouts.
    pub wdt_timeout: u32,
    /// Audio packets received.
    pub audio_total: u32,
    /// Audio packets dropped.
    pub audio_dropped: u32,
    /// Audio sequence errors.
    pub audio_seq_errors: u32,
    /// Ancillary-data packets received.
    pub anc_total: u32,
    /// Ancillary-data packets dropped.
    pub anc_dropped: u32,
    /// Ancillary-data sequence errors.
    pub anc_seq_errors: u32,
    /// The decoder's health state: 0 unknown, 1 healthy, 2 bad, 3 starting.
    ///
    /// Only healthy and bad are verdicts. Reading failure as "not healthy"
    /// counts a decoder that is merely coming up as one that failed, which is
    /// what every sink reports for a moment after a route change.
    pub decoder_state: u8,
}

impl From<V2ipRxStats> for mxr_v2ip_rx_stats_t {
    fn from(s: V2ipRxStats) -> Self {
        Self {
            video_total: s.video_total,
            video_dropped: s.video_dropped,
            video_seq_errors: s.video_seq_errors,
            wdt_timeout: s.wdt_timeout,
            audio_total: s.audio_total,
            audio_dropped: s.audio_dropped,
            audio_seq_errors: s.audio_seq_errors,
            anc_total: s.anc_total,
            anc_dropped: s.anc_dropped,
            anc_seq_errors: s.anc_seq_errors,
            decoder_state: s.decoder_state.to_wire(),
        }
    }
}

/// What a statistics report says about a sink's decoder.
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum mxr_v2ip_decoder_detail_t {
    /// The report carried no decoder block: the sender's firmware predates it.
    MXR_V2IP_DECODER_ABSENT = 0,
    /// The block is there and the decoder has never answered.
    MXR_V2IP_DECODER_NEVER_ANSWERED = 1,
    /// The block carries a reading.
    MXR_V2IP_DECODER_ANSWERED = 2,
}

/// What a sink's decoder recovered from the codestream it is being given.
///
/// This is what the decoder understood, read ahead of the scaler: the geometry
/// is unrounded and is not what the display is being sent. Every field but
/// `detail` is zero unless `detail` is `MXR_V2IP_DECODER_ANSWERED`.
///
/// `detail` follows the sink being configured rather than the sink being
/// enabled, so a sink that is switched off still reports - as reason 10, or
/// from an older sender as reason 1, which is the same reading a sink whose
/// source has died produces. Nothing here answers whether a sink is enabled.
///
/// Colour depth is absent on purpose and will stay absent: the video processor
/// answers that from a driver constant rather than from the codestream, so
/// there is no reading to carry. Assert depth at the encoder's input bay
/// instead.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_decoder_t {
    /// Which of the three states this report is in.
    pub detail: mxr_v2ip_decoder_detail_t,
    /// The primary cause of the state the decoder is in, by the sender's own
    /// names: 0 OK, 1 NO_PACKETS, 2 PACKETS_DEGRADED, 3 NO_FORMAT, 4
    /// FORMAT_MISMATCH, 5 FORMAT_REJECTED, 6 DECODER_BLOCKED, 7
    /// SWITCH_PENDING, 8 PTP_UNLOCKED, 9 TX_BRIDGE_UNLOCKED, 10 IDLE.
    /// Firmware adds causes, so an unrecognised value is passed through as it
    /// arrived.
    ///
    /// The primary cause only, and the numbers are identities rather than
    /// ranks: several causes can be true at once and a fixed priority order in
    /// the firmware decides which lands here. Classify on `flags`, which
    /// carries all of them; a test against this field asks which cause won
    /// instead. Reason 10 is the exception and is read here: it outranks the
    /// whole word, and testing it first is what stops a switched-off sink
    /// being reported as broken. Reason 9 is the one most often hidden here —
    /// see `flags`.
    ///
    /// A pending switch is a step in an operation someone asked for rather
    /// than a fault, and PTP unlocked costs audio alone: audio cannot enable
    /// and the picture is unaffected, so reporting it as a fault puts an
    /// overlay over a good picture. Reason 10 says the sink is switched off,
    /// and carries no implication about `width` and `height`: those are read
    /// before any cause is decided, so a switched-off sink still detecting a
    /// codestream reports a real geometry. An older sender reports reason 1
    /// for the same sink, so an absent reason 10 is not evidence a sink is
    /// enabled - nothing here answers that, which comes from
    /// `mxr_v2ip_details()` or the device's HTTP status.
    pub reason: u8,
    /// The converter watchdog is holding the stream back.
    pub blocking: bool,
    /// The recovered picture width, and 0 when none was recovered.
    pub width: u16,
    /// The recovered picture height, and 0 when none was recovered.
    pub height: u16,
    /// The recovered colour space: 0 RGB, 1 YCbCr 4:4:4, 2 YCbCr 4:2:2,
    /// 3 YCbCr 4:2:0, 255 the decoder cannot name it.
    ///
    /// No value here means "no signal": a decoder with nothing to decode
    /// reports 0, which is indistinguishable from a real RGB reading. A zero
    /// `width` or `height` is what says the decoder recovered nothing - which
    /// is not the same as the sink being switched off, and does not imply it. The 255
    /// is its own value rather than the 0xF a signal report uses for an
    /// unknown colour space.
    pub format: u16,
    /// How many readings the sink has stored. Monotonic, wrapping at 65535
    /// after some 36 hours, and never reset.
    ///
    /// A sink reads its video processor every two seconds and reports every
    /// second, so roughly every other report repeats a reading already seen:
    /// a frame arriving says nothing about how fresh the values in it are.
    /// This counter moves only when a reading is stored, so a processor that
    /// stopped answering leaves it still rather than implying a refresh.
    ///
    /// After pointing a sink at something else, wait for this to advance by
    /// two before trusting the geometry. It ticks when a reply lands rather
    /// than when a query is sent, so the first tick can carry an answer the
    /// processor read fractionally before the switch; the second cannot,
    /// because at most one query is outstanding at a time.
    pub updates: u16,
    /// Every cause that applies, as bit N for reason N, where `reason` carries
    /// the primary one. Bit 0 is cleared by the sender, so an empty word means
    /// nothing beyond the primary cause applies.
    ///
    /// This is what to classify on, once reason 10 has been ruled out. That
    /// cause outranks the whole word and leaves the bits below it set - a sink
    /// switched off while running keeps the bits the decoder genuinely saw on
    /// the way down - so a fault mask over `flags` reports a deliberately
    /// disabled sink as broken.
    ///
    /// A cause that is true can be missing from
    /// `reason` and present here: reason 9, the pipeline rebuilding after the
    /// transmitter bridge stayed unlocked, sits below every input-side cause,
    /// so a pipeline restarting in a loop shows an input-side cause in
    /// `reason` and bit 9 here alone - always, rather than briefly. Bit 9
    /// needs a sustained five seconds to appear at all, and sustained across
    /// reports it means a restart loop rather than one event, because the
    /// sender's debounce restarts each time it elapses.
    ///
    /// Reasons 3 and 4 are the two arms of one decision and never appear
    /// together.
    pub flags: u32,
    /// How many times the converter watchdog has triggered.
    pub blocked_count: u32,
}

impl From<V2ipDecoderDetail> for mxr_v2ip_decoder_t {
    fn from(detail: V2ipDecoderDetail) -> Self {
        let empty = Self {
            detail: mxr_v2ip_decoder_detail_t::MXR_V2IP_DECODER_ABSENT,
            reason: 0,
            blocking: false,
            width: 0,
            height: 0,
            format: 0,
            updates: 0,
            flags: 0,
            blocked_count: 0,
        };
        match detail {
            V2ipDecoderDetail::Absent => empty,
            V2ipDecoderDetail::NeverAnswered => Self {
                detail: mxr_v2ip_decoder_detail_t::MXR_V2IP_DECODER_NEVER_ANSWERED,
                ..empty
            },
            V2ipDecoderDetail::Answered(r) => Self {
                detail: mxr_v2ip_decoder_detail_t::MXR_V2IP_DECODER_ANSWERED,
                reason: r.reason.to_wire(),
                blocking: r.blocking,
                width: r.width,
                height: r.height,
                format: r.format.to_wire(),
                updates: r.updates,
                flags: r.flags,
                blocked_count: r.blocked_count,
            },
        }
    }
}

/// A device's V2IP statistics, cumulative and over the last minute.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_stats_t {
    /// Transmit totals since boot.
    pub tx: mxr_v2ip_tx_stats_t,
    /// Transmit counts over the last minute.
    pub tx_per_minute: mxr_v2ip_tx_stats_t,
    /// Receive totals since boot.
    pub rx: mxr_v2ip_rx_stats_t,
    /// Receive counts over the last minute.
    pub rx_per_minute: mxr_v2ip_rx_stats_t,
    /// What the sink's decoder recovered from the codestream it is decoding.
    pub decoder: mxr_v2ip_decoder_t,
}

/// The window a sink is currently told to show.
///
/// This is the pollable view of a sink's window, not the persisted video wall
/// setting: on a sink running the wall module a write here is transient,
/// because that module pushes its own target window back within about a
/// second.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_tiling_config_t {
    /// The sink this window belongs to.
    pub target: mxr_uid_t,
    /// Window origin, horizontal.
    pub pos_x: u16,
    /// Window origin, vertical.
    pub pos_y: u16,
    /// Window width.
    pub width: u16,
    /// Window height.
    pub height: u16,
}

/// What a multiviewer reports about itself.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_multiviewer_status_t {
    /// The multiviewer.
    pub uid: mxr_uid_t,
    /// The source device mapped to each input.
    pub mappings: [mxr_uid_t; MXR_MULTIVIEWER_INPUTS],
    /// The MCU firmware version.
    pub mcu_version: [c_char; MXR_NAME_LEN],
    /// The scaler firmware version.
    pub scaler_version: [c_char; MXR_NAME_LEN],
    /// The view mode the hardware reports, which is its own numbering rather
    /// than `view_mode`'s.
    pub hw_view_mode: u8,
    /// The window layout.
    pub view_mode: u8,
    /// Which corner the picture-in-picture window sits in.
    pub pip_position: u8,
    /// The size of the picture-in-picture window.
    pub pip_size: u8,
    /// The output resolution.
    pub output_mode: u8,
    /// The HDCP mode.
    pub hdcp_mode: u8,
    /// The IT content flag.
    pub output_itc: u8,
    /// The EDID presented to sources.
    pub edid_template: u8,
    /// How a two, three or four screen layout is arranged: 1 large, 2 small,
    /// 0 in a single or picture-in-picture layout or while the hardware has
    /// not said.
    pub screen_mode: u8,
    /// How a source is fitted into its window.
    pub aspect_ratio: u8,
    /// Whether automatic source switching is on.
    pub auto_switch: u8,
    /// Which window the audio is taken from.
    pub audio_source: u8,
    /// Whether a volume has been reported.
    pub has_audio_volume: bool,
    /// The output volume.
    pub audio_volume: u8,
    /// Whether the output is muted.
    pub audio_muted: u8,
    /// The source shown in each window.
    pub video_sources: [u8; MXR_MULTIVIEWER_INPUTS],
    /// Which window remote control is forwarded to.
    pub remote_control: u8,
}

/// One node of a device's audio tree.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_audio_endpoint_t {
    /// The endpoint's identifier on its device.
    pub id: u8,
    /// What the endpoint can do, as `MXR_AUDIO_*` bits.
    pub features: u32,
    /// Whether the endpoint carries a stream address.
    pub has_address: bool,
    /// The stream address, meaningful only when `has_address` is set.
    pub address: mxr_stream_source_t,
    /// The endpoint this one hangs off, or -1 at a root.
    pub parent: i16,
    /// How many children this endpoint has; read them with
    /// `mxr_audio_endpoint_children()`.
    pub child_count: usize,
    /// Whether the device reported which inputs are selectable.
    pub has_inputs_available: bool,
    /// Bitmask of the endpoints this one may be switched to.
    pub inputs_available: u32,
    /// Whether the device reported which input is selected.
    pub has_inputs_routed: bool,
    /// Bitmask of the endpoint this one is listening to.
    pub inputs_routed: u32,
    /// The device at the other end of the link, zero when unlinked.
    pub linked_device: mxr_uid_t,
    /// The endpoint at the other end of the link, or -1 when unlinked.
    pub linked_endpoint: i16,
}

impl From<&AudioEndpoint> for mxr_audio_endpoint_t {
    fn from(e: &AudioEndpoint) -> Self {
        Self {
            id: e.id,
            features: e.features.bits(),
            has_address: e.address.is_some(),
            address: e.address.unwrap_or_default().into(),
            // An endpoint id is a byte on the wire, so -1 cannot collide.
            parent: e.parent.map_or(-1, i16::from),
            child_count: e.children.len(),
            has_inputs_available: e.inputs_available.is_some(),
            inputs_available: e.inputs_available.unwrap_or(0),
            has_inputs_routed: e.inputs_routed.is_some(),
            inputs_routed: e.inputs_routed.unwrap_or(0),
            linked_device: e.linked_device.into(),
            linked_endpoint: e.linked_endpoint.map_or(-1, i16::from),
        }
    }
}

/// The diagnostic result for one UTP cable pair.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_cable_status_t {
    /// Whether the pair is wired with normal polarity.
    pub polarity: bool,
    /// Which pair this describes.
    pub pair: u8,
    /// Measured skew.
    pub skew: u32,
    /// Measured length.
    pub length: u32,
}

impl From<UtpCableStatus> for mxr_cable_status_t {
    fn from(c: UtpCableStatus) -> Self {
        Self {
            polarity: c.polarity,
            pair: c.pair,
            skew: c.skew,
            length: c.length,
        }
    }
}

/// The link state and diagnostics of one network port.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_network_port_t {
    /// Port number.
    pub port: u16,
    /// Port name.
    pub name: [c_char; MXR_NAME_LEN],
    /// Negotiated link speed.
    pub link_speed: u8,
    /// Whether the link negotiated full duplex.
    pub link_full_duplex: bool,
    /// The port's own address, empty when it has not reported one.
    pub ip: [c_char; MXR_IP_STRING_LEN],
    /// The IGMP querier the port sees, empty when it sees none.
    pub querier: [c_char; MXR_IP_STRING_LEN],
    /// Whether the port reported a hardware address.
    pub has_mac_address: bool,
    /// The hardware address, meaningful only when `has_mac_address` is set.
    pub mac_address: [u8; 6],
    /// Whether the port reported link errors.
    pub has_errors: bool,
    /// Input errors.
    pub in_error: bool,
    /// Input frame check errors.
    pub in_fcs_error: bool,
    /// Input collisions.
    pub in_collision: bool,
    /// Deferred transmissions.
    pub out_deferred: bool,
    /// Excessive transmissions.
    pub out_excessive: bool,
    /// Polarity errors.
    pub polarity_error: bool,
    /// Skew warning.
    pub skew_warning: bool,
    /// Length warning.
    pub length_warning: bool,
    /// Whether the port reported a virtual cable test.
    pub has_vct_status: bool,
    /// Whether each pair raised a warning, meaningful only when
    /// `has_vct_status` is set.
    pub vct_warning: [bool; MXR_UTP_PAIRS],
    /// How many entries of `cable_status` the port filled in.
    pub cable_status_count: usize,
    /// Cable diagnostics per pair.
    pub cable_status: [mxr_cable_status_t; MXR_UTP_PAIRS],
}

/// One device a unit found behind its switch ports, in its topology report.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_topology_entry_t {
    /// The device this entry describes.
    pub uid: mxr_uid_t,
    /// The sender's switch ports this device's MAC address was learnt on, one
    /// bit per port.
    pub mask: u32,
}

impl From<TopologyEntry> for mxr_topology_entry_t {
    fn from(e: TopologyEntry) -> Self {
        Self {
            uid: e.uid.into(),
            mask: e.mask,
        }
    }
}

/// One firmware component a device reports.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_firmware_version_t {
    /// Which component this describes: 0 the unit's firmware, 1 the video
    /// processor's FPGA image, 2 its RTOS image, 3 its loader image, 4 the
    /// unit's bootloader.
    pub firmware_type: u8,
    /// When the image was built or installed, in seconds since the Unix epoch,
    /// or 0 when it carries no time.
    pub timestamp: u32,
    /// Checksum of the image.
    pub hash: u32,
    /// Human-readable version string.
    pub version: [c_char; MXR_VERSION_LEN],
}

/// A ProAmp8's Dolby settings.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_dolby_settings_t {
    /// 0 = standard, 1 = 3-zone Dolby, 2 = 4-zone Dolby.
    pub mode: u8,
    /// Whether PCM is up-mixed to 5.1 rather than passed through.
    pub pcm_upmix: bool,
    /// Whether a Dolby stream was detected.
    pub dolby_detected: bool,
    /// Whether up-mixing is currently running.
    pub pcm_upmix_active: bool,
}

impl From<AmpDolbySettings> for mxr_dolby_settings_t {
    fn from(s: AmpDolbySettings) -> Self {
        Self {
            mode: s.mode,
            pcm_upmix: s.pcm_upmix,
            dolby_detected: s.dolby_detected,
            pcm_upmix_active: s.pcm_upmix_active,
        }
    }
}

/// The remote-control configuration of a source bay.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_rc_settings_t {
    /// The device this configuration belongs to.
    pub target: mxr_uid_t,
    /// The control method, as the wire value.
    ///
    /// Zero is infrared, a method a bay really uses, so it is not a stand-in
    /// for "not reported". Check that `mxr_rc_settings()` returned `MXR_OK`
    /// before reading this: a device that has not sent its settings yet
    /// leaves the struct as the caller allocated it, and a zeroed one then
    /// reads as a bay set to infrared. `mxr_bay_info_t` answers the same
    /// question with a `has_rc_type` flag beside its `rc_type`.
    pub rc_target: u8,
    /// The control target's address, empty when unset.
    pub ip: [c_char; MXR_IP_STRING_LEN],
    /// Whether CEC is enabled.
    pub cec_enabled: bool,
    /// Whether CEC powers the sink on automatically.
    pub cec_auto_on: bool,
    /// Whether remote-control commands are forwarded.
    pub forward_rc: bool,
    /// Whether infrared is forwarded.
    pub forward_ir: bool,
    /// The driver state on the source, as the wire value. One above the last
    /// this library knows is passed through as it arrived.
    pub rc_status: u8,
    /// The driver-reported status string, empty when unknown.
    pub status_name: [c_char; MXR_NAME_LEN],
}

/// Writes an address into a fixed-width field, leaving it empty when there is
/// none.
fn put_ip(dst: &mut [c_char], ip: Option<Ipv4Addr>) {
    put_str(dst, &ip.map(|ip| ip.to_string()).unwrap_or_default());
}

/// Declares a getter for one subsystem of a device.
///
/// Each has the same three answers - no such device, the device has not sent
/// this, here it is - and writing them out once keeps a getter that answers
/// differently visible as one.
/// Writes a subsystem reading through `out`, or reports why there is none.
///
/// # Safety
///
/// `out` is null or points at a writable `T`.
unsafe fn fill<T>(
    r: &mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut T,
    what: &str,
    value: Option<T>,
) -> mxr_result_t {
    if out.is_null() {
        return null_out(what);
    }
    match value {
        Some(value) => {
            // SAFETY: the caller guarantees a writable T, and it is not null.
            unsafe { *out = value };
            mxr_result_t::MXR_OK
        }
        None => not_reported(r, uid, what),
    }
}

/// Reports why a subsystem read found nothing: no such device, or a device
/// that has not sent this.
fn not_reported(r: &mxr_remote_t, uid: mxr_uid_t, what: &str) -> mxr_result_t {
    if r.remote.device(uid.into()).is_none() {
        return not_heard_from(uid);
    }
    fail(
        mxr_result_t::MXR_ERR_NOT_REPORTED,
        &format!("the device has reported no {what}"),
    )
}

/// Fills `out` with a device's V2IP statistics.
///
/// A device sends these only while subscribed; see
/// `mxr_subscribe_v2ip_stats()`.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// [`mxr_v2ip_stats_t`].
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_stats(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_v2ip_stats_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .v2ip_stats(uid.into())
            .map(|s: V2ipDeviceStats| mxr_v2ip_stats_t {
                tx: s.tx.into(),
                tx_per_minute: s.tx_per_minute.into(),
                rx: s.rx.into(),
                rx_per_minute: s.rx_per_minute.into(),
                decoder: s.decoder.into(),
            });
        // SAFETY: the caller guarantees a writable mxr_v2ip_stats_t or null.
        unsafe { fill(r, uid, out, "V2IP statistics", value) }
    })
}

/// Fills `out` with a V2IP device's own encoder configuration.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// [`mxr_v2ip_details_t`].
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_details(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_v2ip_details_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .v2ip_details(uid.into())
            .map(|d: DeviceV2ipDetails| mxr_v2ip_details_t {
                video: d.video.into(),
                audio: d.audio.into(),
                anc: d.anc.into(),
                arc: d.arc.into(),
                // A rate and a marking are both bytes on the wire, so -1 cannot
                // collide with a value a device could report.
                tx_rate: d.tx_rate.map_or(-1, i16::from),
                dscp_video: d.dscp.video.map_or(-1, i16::from),
                dscp_audio: d.dscp.audio.map_or(-1, i16::from),
                dscp_anc: d.dscp.anc.map_or(-1, i16::from),
                scaling_mode: d.scaling.mode.to_wire(),
                scaling_refresh: d.scaling.refresh,
                scaling_flags: d.scaling.flags,
            });
        // SAFETY: the caller guarantees a writable mxr_v2ip_details_t or null.
        unsafe { fill(r, uid, out, "V2IP encoder configuration", value) }
    })
}

/// Fills `out` with the streams a V2IP sink is subscribed to.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// [`mxr_v2ip_sink_t`].
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_sink(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_v2ip_sink_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .v2ip_sink(uid.into())
            .map(|s: DeviceV2ipSink| mxr_v2ip_sink_t {
                addresses: s.addresses.into(),
                has_audio_format: s.audio_fmt.is_some(),
                audio_format: {
                    let f = s.audio_fmt.unwrap_or_default();
                    mxr_audio_format_t {
                        sample_rate: f.sample_rate,
                        channels: f.channels,
                    }
                },
            });
        // SAFETY: the caller guarantees a writable mxr_v2ip_sink_t or null.
        unsafe { fill(r, uid, out, "V2IP sink route", value) }
    })
}

/// Fills `out` with what a V2IP device's video processor supports.
///
/// Reports `MXR_ERR_NOT_REPORTED` while the device has not said: a processor
/// that has yet to answer and one with none of the optional commands send the
/// same empty mask, so neither is reported as a capability set.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `uint64_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_features(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut u64,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .v2ip_features(uid.into())
            .map(V2ipFpgaFeature::bits);
        // SAFETY: the caller guarantees a writable uint64_t or null.
        unsafe { fill(r, uid, out, "processor features", value) }
    })
}

/// A V2IP device's settings.
///
/// A setting is reported only when its `MXR_V2IP_SETTING_*` bit is set in
/// `valid`, and a device reports every setting it has.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_device_settings_t {
    /// `MXR_V2IP_SETTING_*` bits of the settings reported so far.
    pub valid: u32,
    /// `MXR_V2IP_SETTING_*` values of the on/off settings among `valid`.
    pub flags: u32,
    /// The infrared profiles stored on the device, bit n for profile n, when
    /// `valid` has `MXR_V2IP_SETTING_IR_PROFILES`.
    pub ir_profiles: u32,
    /// The global infrared port's profile, when `valid` has
    /// `MXR_V2IP_SETTING_IR_PROFILE`.
    pub ir_profile: i8,
    /// The output infrared port's profile, when `valid` has
    /// `MXR_V2IP_SETTING_IR_PROFILE_SINK`. `MXR_V2IP_IR_PROFILE_NOT_SET` means
    /// it follows the global one.
    pub ir_profile_sink: i8,
}

/// The output infrared port follows the global one.
pub const MXR_V2IP_IR_PROFILE_NOT_SET: i8 = -1;
/// One past the highest infrared profile.
pub const MXR_V2IP_IR_PROFILE_MAX: i8 = 18;

// The header carries these as literals, so they are held to the core's here.
const _: () = assert!(MXR_V2IP_IR_PROFILE_NOT_SET == mx_remote::V2IP_IR_PROFILE_NOT_SET);
const _: () = assert!(MXR_V2IP_IR_PROFILE_MAX == mx_remote::V2IP_IR_PROFILE_MAX);

/// Fills `out` with a V2IP device's settings.
///
/// Reports `MXR_ERR_NOT_REPORTED` until the device has reported any. A change
/// is announced through `on_device_update`.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `mxr_v2ip_device_settings_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_device_settings(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_v2ip_device_settings_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .v2ip_device_settings(uid.into())
            .map(|s: V2ipDeviceSettings| mxr_v2ip_device_settings_t {
                valid: s.valid.bits(),
                flags: s.flags.bits(),
                ir_profiles: s.ir_profiles,
                ir_profile: s.ir_profile,
                ir_profile_sink: s.ir_profile_sink,
            });
        // SAFETY: the caller guarantees a writable struct or null.
        unsafe { fill(r, uid, out, "device settings", value) }
    })
}

/// A V2IP device's power save settings, beside `mxr_v2ip_device_settings_t`
/// rather than in it so that struct keeps its size.
///
/// Which of them the device has reported is in that struct's `valid`.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_power_save_t {
    /// The idle minutes before the device powers down by itself, 0 for never,
    /// when `valid` has `MXR_V2IP_SETTING_AUTO_POWER_SAVE`.
    pub auto_minutes: u16,
    /// When each day's power save window starts, Monday first, in minutes
    /// after midnight in the device's time zone, when `valid` has
    /// `MXR_V2IP_SETTING_POWER_SAVE_SCHEDULE`.
    pub start: [u16; 7],
    /// When each day's window ends. A window ending before it starts runs
    /// past midnight, and one ending where it starts means none that day.
    pub end: [u16; 7],
}

/// Minutes in a day: every power save time is below this.
pub const MXR_V2IP_MINUTES_PER_DAY: u16 = 1440;

const _: () = assert!(MXR_V2IP_MINUTES_PER_DAY == mx_remote::V2IP_MINUTES_PER_DAY);

/// Fills `out` with a V2IP device's power save settings.
///
/// Reports `MXR_ERR_NOT_REPORTED` until the device has reported any settings;
/// `mxr_v2ip_device_settings()` says which of these it has.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `mxr_v2ip_power_save_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_power_save(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_v2ip_power_save_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .v2ip_device_settings(uid.into())
            .map(|s: V2ipDeviceSettings| mxr_v2ip_power_save_t {
                auto_minutes: s.auto_power_save,
                start: s.power_save.start,
                end: s.power_save.end,
            });
        // SAFETY: the caller guarantees a writable struct or null.
        unsafe { fill(r, uid, out, "device settings", value) }
    })
}

/// A V2IP device's PTP settings, beside `mxr_v2ip_device_settings_t` rather
/// than in it so that struct keeps its size.
///
/// Which of them the device has reported is in that struct's `valid`.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_ptp_settings_t {
    /// `MXR_V2IP_PTP_MODE_*`, when `valid` has `MXR_V2IP_SETTING_PTP_MODE`.
    pub mode: u8,
    /// The domain, at most `MXR_V2IP_PTP_DOMAIN_MAX`, when `valid` has
    /// `MXR_V2IP_SETTING_PTP_DOMAIN`.
    pub domain: u8,
    /// The priority1 the device announces as a grandmaster, lower winning,
    /// when `valid` has `MXR_V2IP_SETTING_PTP_PRIORITY1`.
    pub priority1: u8,
}

/// The highest PTP domain a V2IP device runs in.
pub const MXR_V2IP_PTP_DOMAIN_MAX: u8 = 127;

const _: () = assert!(MXR_V2IP_PTP_DOMAIN_MAX == mx_remote::V2IP_PTP_DOMAIN_MAX);

/// Fills `out` with a V2IP device's PTP settings.
///
/// Reports `MXR_ERR_NOT_REPORTED` until the device has reported any settings;
/// `mxr_v2ip_device_settings()` says which of these it has.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `mxr_v2ip_ptp_settings_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_ptp_settings(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_v2ip_ptp_settings_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .v2ip_device_settings(uid.into())
            .map(|s: V2ipDeviceSettings| mxr_v2ip_ptp_settings_t {
                mode: s.ptp_mode.to_wire(),
                domain: s.ptp_domain,
                priority1: s.ptp_priority1,
            });
        // SAFETY: the caller guarantees a writable struct or null.
        unsafe { fill(r, uid, out, "device settings", value) }
    })
}

/// Bytes in `mxr_time_zone_t.zone`, its NUL included.
pub const MXR_TIME_ZONE_NAME_LEN: usize = 48;
/// Bytes in `mxr_time_zone_t.rule`, its NUL included.
pub const MXR_TIME_ZONE_RULE_LEN: usize = 64;

const _: () = assert!(MXR_TIME_ZONE_NAME_LEN == mx_remote::TIME_ZONE_NAME_LEN);
const _: () = assert!(MXR_TIME_ZONE_RULE_LEN == mx_remote::TIME_ZONE_RULE_LEN);

/// The time zone a device announces for its mesh. An empty name and rule mean
/// the controller has none, and the devices keep UTC.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_time_zone_t {
    /// The IANA name, such as `Europe/Amsterdam`.
    pub zone: [c_char; MXR_TIME_ZONE_NAME_LEN],
    /// The POSIX TZ rule the devices keep time by.
    pub rule: [c_char; MXR_TIME_ZONE_RULE_LEN],
}

/// Fills `out` with the time zone a device announced for its mesh.
///
/// Reports `MXR_ERR_NOT_REPORTED` until it has announced one; the mesh
/// controller does with every periodic broadcast. A change is announced
/// through `on_device_update`.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `mxr_time_zone_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_time_zone(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_time_zone_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r.remote.time_zone(uid.into()).map(|tz| {
            let mut out = mxr_time_zone_t {
                zone: [0; MXR_TIME_ZONE_NAME_LEN],
                rule: [0; MXR_TIME_ZONE_RULE_LEN],
            };
            put_str(&mut out.zone, &tz.zone);
            put_str(&mut out.rule, &tz.rule);
            out
        });
        // SAFETY: the caller guarantees a writable struct or null.
        unsafe { fill(r, uid, out, "time zone", value) }
    })
}

/// Fills `out` with a device's clock as of now, in seconds since 1970 UTC:
/// the time it last announced, advanced by how long ago that arrived.
///
/// Reports `MXR_ERR_NOT_REPORTED` until it has announced one; the mesh
/// controller does with every periodic broadcast once its clock is set.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `uint64_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_device_clock(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut u64,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .device_clock(uid.into())
            .and_then(|t| t.duration_since(UNIX_EPOCH).ok())
            .map(|d| d.as_secs());
        // SAFETY: the caller guarantees a writable uint64_t or null.
        unsafe { fill(r, uid, out, "clock", value) }
    })
}

/// VLAN tagging on a V2IP device's uplink.
///
/// Only the device knows what it runs, so this is what it reported about
/// itself. A change written to it is applied at once and carries
/// `MXR_V2IP_VLAN_PENDING` until the mesh controller confirms it; unconfirmed,
/// the device reverts it.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_vlan_t {
    /// `MXR_V2IP_VLAN_*` bits.
    pub flags: u16,
    /// The VLAN id of the device's own traffic, 0 for untagged.
    pub device: u16,
    /// The VLAN id each downlink port carries, 0 to share the device's
    /// untagged traffic: the SFP port, the UTP port with PoE, then the UTP
    /// port.
    pub port: [u16; MXR_V2IP_VLAN_PORTS],
    /// The port pinned as the uplink as 1 + its index in `port`, 0 to detect
    /// it.
    pub uplink: u8,
    /// Reported by the device: the port in use as the uplink, as 1 + its
    /// index in `port`.
    pub active_uplink: u8,
    /// Reported by the device: the seconds before a pending configuration is
    /// reverted.
    pub revert_s: u8,
}

/// The ports in `mxr_v2ip_vlan_t::port`.
pub const MXR_V2IP_VLAN_PORTS: usize = 3;
/// The index of the SFP port in `mxr_v2ip_vlan_t::port`.
pub const MXR_V2IP_VLAN_PORT_SFP: usize = 0;
/// The highest VLAN id: 0 means untagged, and 4095 is reserved by IEEE 802.1Q.
pub const MXR_V2IP_VLAN_ID_MAX: u16 = 4094;

const _: () = assert!(MXR_V2IP_VLAN_PORTS == mx_remote::V2IP_VLAN_PORTS);
const _: () = assert!(MXR_V2IP_VLAN_PORT_SFP == mx_remote::V2IP_VLAN_PORT_SFP);
const _: () = assert!(MXR_V2IP_VLAN_ID_MAX == mx_remote::V2IP_VLAN_ID_MAX);

/// Fills `out` with the VLAN configuration a V2IP device last reported.
///
/// Reports `MXR_ERR_NOT_REPORTED` until the device has reported one. A change
/// is announced through `on_device_update`.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `mxr_v2ip_vlan_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_vlan(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_v2ip_vlan_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .v2ip_vlan(uid.into())
            .map(|v: V2ipVlan| mxr_v2ip_vlan_t {
                flags: v.flags.bits(),
                device: v.device,
                port: v.port,
                uplink: v.uplink,
                active_uplink: v.active_uplink,
                revert_s: v.revert_s,
            });
        // SAFETY: the caller guarantees a writable struct or null.
        unsafe { fill(r, uid, out, "VLAN configuration", value) }
    })
}

/// The most temperatures a unit reports.
pub const MXR_UNIT_MAX_TEMPERATURES: usize = 6;
/// Bytes in `mxr_unit_status_t.status_message`, its NUL included.
pub const MXR_UNIT_STATUS_MESSAGE_LEN: usize = 49;

const _: () = assert!(MXR_UNIT_MAX_TEMPERATURES == mx_remote::UNIT_MAX_TEMPERATURES);

/// A unit's health and IP configuration, as it last reported them.
/// Addresses are dotted quads.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_unit_status_t {
    /// `MXR_UNIT_*` bits.
    pub flags: u32,
    /// Seconds since the unit booted.
    pub uptime: u32,
    /// How often the unit has booted, when `flags` has `MXR_UNIT_BOOT_COUNT`.
    pub boot_count: u32,
    /// How often the unit has rebooted.
    pub reboot_count: u32,
    /// The encoder's health, a mask of the unit's encoder status bits.
    pub encoder_health: u32,
    /// The decoder's health, a mask of the unit's decoder status and state
    /// bits.
    pub decoder_health: u32,
    /// The address in use.
    pub ip: [c_char; MXR_IP_STRING_LEN],
    /// The netmask in use.
    pub netmask: [c_char; MXR_IP_STRING_LEN],
    /// The gateway in use.
    pub gateway: [c_char; MXR_IP_STRING_LEN],
    /// The primary DNS server in use.
    pub dns1: [c_char; MXR_IP_STRING_LEN],
    /// The secondary DNS server in use.
    pub dns2: [c_char; MXR_IP_STRING_LEN],
    /// The fan speed in RPM, when `flags` has `MXR_UNIT_FAN_SPEED`.
    pub fan_rpm: u16,
    /// The fan duty cycle, in percent.
    pub fan_duty: u8,
    /// The unit's system status.
    pub status: u8,
    /// Seconds before a pending IP configuration is reverted.
    pub net_revert_s: u8,
    /// How many of `temperatures` are reported.
    pub nb_temperatures: u8,
    /// Temperatures, in degrees Celsius.
    pub temperatures: [i8; MXR_UNIT_MAX_TEMPERATURES],
    /// The message of the current system status.
    pub status_message: [c_char; MXR_UNIT_STATUS_MESSAGE_LEN],
}

/// Fills `out` with the health and IP configuration a unit last reported.
///
/// Reports `MXR_ERR_NOT_REPORTED` until the unit has reported them. A change
/// is announced through `on_device_update`.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `mxr_unit_status_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_unit_status(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_unit_status_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r.remote.unit_status(uid.into()).map(|s: UnitStatus| {
            let mut out = mxr_unit_status_t {
                flags: s.flags.bits(),
                uptime: s.uptime,
                boot_count: s.boot_count,
                reboot_count: s.reboot_count,
                encoder_health: s.encoder_health,
                decoder_health: s.decoder_health,
                ip: [0; MXR_IP_STRING_LEN],
                netmask: [0; MXR_IP_STRING_LEN],
                gateway: [0; MXR_IP_STRING_LEN],
                dns1: [0; MXR_IP_STRING_LEN],
                dns2: [0; MXR_IP_STRING_LEN],
                fan_rpm: s.fan_rpm,
                fan_duty: s.fan_duty,
                status: s.status,
                net_revert_s: s.net_revert_s,
                nb_temperatures: s.temperatures.len() as u8,
                temperatures: [0; MXR_UNIT_MAX_TEMPERATURES],
                status_message: [0; MXR_UNIT_STATUS_MESSAGE_LEN],
            };
            put_ip(&mut out.ip, Some(s.network.ip));
            put_ip(&mut out.netmask, Some(s.network.netmask));
            put_ip(&mut out.gateway, Some(s.network.gateway));
            put_ip(&mut out.dns1, Some(s.network.dns1));
            put_ip(&mut out.dns2, Some(s.network.dns2));
            for (slot, t) in out.temperatures.iter_mut().zip(&s.temperatures) {
                *slot = *t;
            }
            put_str(&mut out.status_message, &s.status_message);
            out
        });
        // SAFETY: the caller guarantees a writable struct or null.
        unsafe { fill(r, uid, out, "unit status", value) }
    })
}

/// Fills `out` with the level a V2IP device powers down to in power save,
/// `MXR_V2IP_POWER_SAVE_LEVEL_*`.
///
/// Reports `MXR_ERR_NOT_REPORTED` until the device has reported any settings;
/// `mxr_v2ip_device_settings()` says whether it has this one.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable byte.
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_power_save_level(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut u8,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .v2ip_device_settings(uid.into())
            .map(|s: V2ipDeviceSettings| s.power_save_level.to_wire());
        // SAFETY: the caller guarantees a writable byte or null.
        unsafe { fill(r, uid, out, "device settings", value) }
    })
}

/// How a V2IP device paces its PTP messages, its SAP timings and its streams'
/// TTL, which a frame carries in the same block. Intervals are base-2
/// logarithms of seconds, so -3 is 125 ms and 1 is 2 s. Each value is
/// meaningful only behind its `MXR_V2IP_SETTING_PTP_*`,
/// `MXR_V2IP_SETTING_SAP_*` or `MXR_V2IP_SETTING_STREAM_TTL` bit in
/// `mxr_v2ip_device_settings_t`'s `valid`.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_ptp_messages_t {
    /// Between announce messages.
    pub log_announce_interval: i8,
    /// Between sync messages.
    pub log_sync_interval: i8,
    /// Between delay requests.
    pub log_delay_req_interval: i8,
    /// The announce intervals before a silent master is dropped.
    pub announce_timeout: u8,
    /// The DSCP of the messages, at most 63.
    pub dscp: u8,
    /// The minutes after which a heard SAP announcement is forgotten.
    pub sap_expire_min: u8,
    /// The seconds between the device's SAP announcements.
    pub sap_interval_s: u16,
    /// The TTL of the device's streams, 1 to 255. A device whose video
    /// processor cannot change it keeps the setting and sends
    /// `MXR_V2IP_STREAM_TTL_DEFAULT`.
    pub stream_ttl: u8,
}

impl From<V2ipPtpMessages> for mxr_v2ip_ptp_messages_t {
    fn from(m: V2ipPtpMessages) -> Self {
        Self {
            log_announce_interval: m.log_announce_interval,
            log_sync_interval: m.log_sync_interval,
            log_delay_req_interval: m.log_delay_req_interval,
            announce_timeout: m.announce_timeout,
            dscp: m.dscp,
            sap_expire_min: m.sap_expire_min,
            sap_interval_s: m.sap_interval_s,
            stream_ttl: m.stream_ttl,
        }
    }
}

impl From<mxr_v2ip_ptp_messages_t> for V2ipPtpMessages {
    fn from(m: mxr_v2ip_ptp_messages_t) -> Self {
        Self {
            log_announce_interval: m.log_announce_interval,
            log_sync_interval: m.log_sync_interval,
            log_delay_req_interval: m.log_delay_req_interval,
            announce_timeout: m.announce_timeout,
            dscp: m.dscp,
            sap_expire_min: m.sap_expire_min,
            sap_interval_s: m.sap_interval_s,
            stream_ttl: m.stream_ttl,
        }
    }
}

/// Fills `out` with how a V2IP device paces its PTP messages.
///
/// Reports `MXR_ERR_NOT_REPORTED` until the device has reported any settings;
/// `mxr_v2ip_device_settings()` says which of these it has.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `mxr_v2ip_ptp_messages_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_ptp_messages(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_v2ip_ptp_messages_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .v2ip_device_settings(uid.into())
            .map(|s: V2ipDeviceSettings| s.ptp_messages.into());
        // SAFETY: the caller guarantees a writable struct or null.
        unsafe { fill(r, uid, out, "device settings", value) }
    })
}

/// The longest session description a V2IP output takes, in bytes.
pub const MXR_V2IP_SDP_MAX: usize = 2048;
/// Bytes in `mxr_v2ip_sink_sdp_t.name`, its NUL included.
pub const MXR_V2IP_SDP_NAME_LEN: usize = 48;
/// Bytes in `mxr_v2ip_sink_sdp_t.layout`, its NUL included.
pub const MXR_V2IP_SDP_LAYOUT_LEN: usize = 8;

const _: () = assert!(MXR_V2IP_SDP_MAX == mx_remote::V2IP_SDP_MAX);

/// What a V2IP output plays from a session description, as it last reported
/// it. The stream's fields are zero while it plays none.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_sink_sdp_t {
    /// `MXR_V2IP_SDP_FLAG_*` bits.
    pub flags: u8,
    /// What the output shows while it plays audio alone.
    pub screen: u8,
    /// `MXR_V2IP_SDP_ENCODING_*`.
    pub encoding: u8,
    /// The channel count.
    pub channels: u8,
    /// The RTP payload type.
    pub payload_type: u8,
    /// `MXR_V2IP_SDP_MEDIA_CLOCK_*`.
    pub media_clock: u8,
    /// `MXR_V2IP_SDP_REF_CLOCK_*`.
    pub ref_clock: u8,
    /// `MXR_V2IP_SDP_CLOCK_MODE_*`, with `MXR_V2IP_SDP_FLAG_CLOCK`.
    pub clock_mode: u8,
    /// `MXR_V2IP_SDP_CLOCK_STATE_*`, with `MXR_V2IP_SDP_FLAG_CLOCK`.
    pub clock_state: u8,
    /// The destination UDP port.
    pub port: u16,
    /// The sample rate, in Hz.
    pub rate_hz: u32,
    /// The media clock offset.
    pub media_clock_offset: u32,
    /// The multicast group, as a dotted quad.
    pub group: [c_char; MXR_IP_STRING_LEN],
    /// The session name.
    pub name: [c_char; MXR_V2IP_SDP_NAME_LEN],
    /// The channel grouping it plays, empty without one.
    pub layout: [c_char; MXR_V2IP_SDP_LAYOUT_LEN],
}

/// Fills `out` with what a V2IP output last reported playing from a session
/// description.
///
/// Reports `MXR_ERR_NOT_REPORTED` until the output has reported; it does when
/// that changes, at least once a minute, and when asked with
/// `mxr_request_v2ip_sink_sdp()`. A change is announced through
/// `on_device_update`.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `mxr_v2ip_sink_sdp_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_sink_sdp(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_v2ip_sink_sdp_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r.remote.v2ip_sink_sdp(uid.into()).map(|s: V2ipSinkSdp| {
            let mut out = mxr_v2ip_sink_sdp_t {
                flags: s.flags.bits(),
                screen: s.screen,
                encoding: s.encoding.to_wire(),
                channels: s.channels,
                payload_type: s.payload_type,
                media_clock: s.media_clock.to_wire(),
                ref_clock: s.ref_clock.to_wire(),
                clock_mode: s.clock_mode.to_wire(),
                clock_state: s.clock_state.to_wire(),
                port: s.port,
                rate_hz: s.rate_hz,
                media_clock_offset: s.media_clock_offset,
                group: [0; MXR_IP_STRING_LEN],
                name: [0; MXR_V2IP_SDP_NAME_LEN],
                layout: [0; MXR_V2IP_SDP_LAYOUT_LEN],
            };
            put_ip(&mut out.group, Some(s.group));
            put_str(&mut out.name, &s.name);
            put_str(&mut out.layout, &s.layout);
            out
        });
        // SAFETY: the caller guarantees a writable struct or null.
        unsafe { fill(r, uid, out, "session description status", value) }
    })
}

/// How one of a V2IP source unit's streams is encrypted: the values of its
/// session description's `a=privacy` and `a=extmap` attributes. The key
/// itself never travels: every unit of a mesh holds the same one. This
/// library holds no key and decrypts nothing.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_privacy_stream_t {
    /// The stream's destination address, as a dotted quad.
    pub group: [c_char; MXR_IP_STRING_LEN],
    /// The stream's UDP port.
    pub port: u16,
    /// Steps whenever the parameters change.
    pub version: u8,
    /// Whether the stream is encrypted. Without it the stream goes out in the
    /// clear, and the fields below mean nothing.
    pub on: bool,
    /// The RTP header extension id of the full IV counter.
    pub full_id: u8,
    /// The RTP header extension id of the short IV counter.
    pub short_id: u8,
    /// The initialisation vector.
    pub iv: [u8; 8],
    /// The key generator.
    pub key_generator: [u8; 16],
    /// Names the mesh's key. A receiver holding another drops the stream.
    pub key_id: [u8; 8],
    /// The key version.
    pub key_version: u32,
}

/// How a V2IP source unit's streams are encrypted, as it last reported it.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_privacy_t {
    /// The video stream.
    pub video: mxr_v2ip_privacy_stream_t,
    /// The audio stream.
    pub audio: mxr_v2ip_privacy_stream_t,
    /// The ancillary data stream.
    pub anc: mxr_v2ip_privacy_stream_t,
}

fn privacy_stream(s: &V2ipPrivacyStream) -> mxr_v2ip_privacy_stream_t {
    let mut out = mxr_v2ip_privacy_stream_t {
        group: [0; MXR_IP_STRING_LEN],
        port: s.port,
        version: s.version,
        on: s.on,
        full_id: s.full_id,
        short_id: s.short_id,
        iv: s.iv,
        key_generator: s.key_generator,
        key_id: s.key_id,
        key_version: s.key_version,
    };
    put_ip(&mut out.group, Some(s.group));
    out
}

/// Fills `out` with how a V2IP source unit's streams are encrypted, as it
/// last reported it.
///
/// Reports `MXR_ERR_NOT_REPORTED` until the unit has reported; it does when
/// that changes, at least once a minute, and when asked with
/// `mxr_request_v2ip_privacy()`. A change is announced through
/// `on_device_update`.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `mxr_v2ip_privacy_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_privacy(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_v2ip_privacy_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .v2ip_privacy(uid.into())
            .map(|p: V2ipPrivacy| mxr_v2ip_privacy_t {
                video: privacy_stream(&p.video),
                audio: privacy_stream(&p.audio),
                anc: privacy_stream(&p.anc),
            });
        // SAFETY: the caller guarantees a writable struct or null.
        unsafe { fill(r, uid, out, "stream encryption", value) }
    })
}

/// The logo slots an overlay sync can copy.
pub const MXR_OSD_SYNC_SLOTS: usize = 4;
/// Bytes in `mxr_osd_sync_report_t.reason`, its NUL included.
pub const MXR_OSD_SYNC_REASON_LEN: usize = 65;

const _: () = assert!(MXR_OSD_SYNC_SLOTS == OSD_SYNC_SLOTS);

/// One logo slot, as an overlay sync describes it.
#[repr(C)]
#[derive(Clone, Copy, Default)]
pub struct mxr_osd_sync_slot_t {
    /// The PNG's size in bytes; zero empties the slot.
    pub bytes: u32,
    /// The PNG's CRC-32.
    pub crc32: u32,
    /// The size it is shown at, in percent.
    pub percent: u8,
}

/// The overlay sync a management unit last sent.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_osd_sync_t {
    /// The sync's number at its source.
    pub seq: u16,
    /// The unit it is for, or zero for every unit.
    pub target: mxr_uid_t,
    /// `MXR_OSD_SYNC_WHAT_*` bits.
    pub what: u8,
    /// The source's HTTP port, zero meaning 80.
    pub http_port: u16,
    /// The source's address as a dotted quad, `0.0.0.0` meaning the
    /// sender's.
    pub source_ip: [c_char; MXR_IP_STRING_LEN],
    /// How many settings follow.
    pub records: u16,
    /// The logo slots, filled when `what` has
    /// `MXR_OSD_SYNC_WHAT_LOGO_SLOTS` and zero otherwise. A unit fetches a
    /// slot whose size or CRC differs from
    /// `http://source_ip:http_port/osd-sync/slotN.png`, N being 1 to 4.
    pub slots: [mxr_osd_sync_slot_t; MXR_OSD_SYNC_SLOTS],
}

/// How a unit last reported getting on with an overlay sync.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_osd_sync_report_t {
    /// The sync it reports on, numbered by the source that sent it.
    pub seq: u16,
    /// `MXR_OSD_SYNC_STATE_*`.
    pub state: u8,
    /// The settings it wrote.
    pub written: u16,
    /// The settings it refused.
    pub refused: u16,
    /// Why it failed or refused any.
    pub reason: [c_char; MXR_OSD_SYNC_REASON_LEN],
}

/// Fills `out` with the overlay sync a management unit last sent.
///
/// Reports `MXR_ERR_NOT_REPORTED` until it has sent one. A new sync is
/// announced through `on_device_update`.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `mxr_osd_sync_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_osd_sync(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_osd_sync_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r.remote.osd_sync(uid.into()).map(|s: OsdSync| {
            let mut out = mxr_osd_sync_t {
                seq: s.seq,
                target: s.target.into(),
                what: s.what.bits(),
                http_port: s.http_port,
                source_ip: [0; MXR_IP_STRING_LEN],
                records: s.records,
                slots: [mxr_osd_sync_slot_t::default(); MXR_OSD_SYNC_SLOTS],
            };
            put_ip(&mut out.source_ip, Some(s.source_ip));
            for (o, slot) in out.slots.iter_mut().zip(s.slots.iter().flatten()) {
                *o = mxr_osd_sync_slot_t {
                    bytes: slot.bytes,
                    crc32: slot.crc32,
                    percent: slot.percent,
                };
            }
            out
        });
        // SAFETY: the caller guarantees a writable struct or null.
        unsafe { fill(r, uid, out, "overlay sync", value) }
    })
}

/// Fills `out` with how a unit last reported getting on with an overlay
/// sync. Match it to the sync by `seq` and the sync's source.
///
/// Reports `MXR_ERR_NOT_REPORTED` until the unit has reported. A change is
/// announced through `on_device_update`.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `mxr_osd_sync_report_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_osd_sync_report(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_osd_sync_report_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .osd_sync_report(uid.into())
            .map(|s: OsdSyncReport| {
                let mut out = mxr_osd_sync_report_t {
                    seq: s.seq,
                    state: s.state.to_wire(),
                    written: s.written,
                    refused: s.refused,
                    reason: [0; MXR_OSD_SYNC_REASON_LEN],
                };
                put_str(&mut out.reason, &s.reason);
                out
            });
        // SAFETY: the caller guarantees a writable struct or null.
        unsafe { fill(r, uid, out, "overlay sync report", value) }
    })
}

/// The power save levels a unit reports what it offers at.
pub const MXR_UNIT_POWER_SAVE_LEVELS: usize = 4;

const _: () = assert!(MXR_UNIT_POWER_SAVE_LEVELS == mx_remote::UNIT_POWER_SAVE_LEVELS);

/// What a unit offers at each power save level.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_unit_power_save_t {
    /// `MXR_UNIT_POWER_SAVE_*` bits of each level, `level[i]` for
    /// `MXR_V2IP_POWER_SAVE_LEVEL_*` i + 1. All zero for a unit that predates
    /// them.
    pub level: [u8; MXR_UNIT_POWER_SAVE_LEVELS],
}

/// Fills `out` with what a unit offers at each power save level, as its last
/// status report carried it.
///
/// Reports `MXR_ERR_NOT_REPORTED` until the unit has reported its status.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `mxr_unit_power_save_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_unit_power_save(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_unit_power_save_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .unit_status(uid.into())
            .map(|s| mxr_unit_power_save_t {
                level: s.power_save.map(|p| p.bits()),
            });
        // SAFETY: the caller guarantees a writable struct or null.
        unsafe { fill(r, uid, out, "unit status", value) }
    })
}

/// A V2IP device's PTP state, as it reported it about itself.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_ptp_t {
    /// `MXR_V2IP_PTP_*` bits.
    pub flags: u8,
    /// `MXR_V2IP_PTP_MODE_*` the video processor runs.
    pub mode: u8,
    /// The domain the video processor runs in.
    pub domain: u8,
    /// The IEEE 1588 portState.
    pub port_state: u8,
    /// `MXR_V2IP_PTP_LOCK_*`.
    pub lock: u8,
    /// The device's own clock identity.
    pub clock_identity: [u8; 8],
    /// The clock identity of the grandmaster the device runs on, all zero
    /// while it runs on none.
    pub grandmaster_identity: [u8; 8],
}

/// Fills `out` with the PTP state a V2IP device last reported about itself.
///
/// Reports `MXR_ERR_NOT_REPORTED` until the device has reported one, and while
/// it has none to report: no PTP on its video processor, or in power save. A
/// change is announced through `on_device_update`.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `mxr_v2ip_ptp_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_ptp(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_v2ip_ptp_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .v2ip_ptp(uid.into())
            .map(|t: V2ipPtpState| mxr_v2ip_ptp_t {
                flags: t.flags.bits(),
                mode: t.mode.to_wire(),
                domain: t.domain,
                port_state: t.port_state,
                lock: t.lock.to_wire(),
                clock_identity: t.clock_identity,
                grandmaster_identity: t.grandmaster_identity,
            });
        // SAFETY: the caller guarantees a writable struct or null.
        unsafe { fill(r, uid, out, "PTP state", value) }
    })
}

/// A V2IP sink's test tone.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_test_tone_t {
    /// `MXR_V2IP_TONE_MODE_*`.
    pub mode: u8,
    /// The level, in dBFS, `MXR_V2IP_TONE_LEVEL_MIN` to 0.
    pub level: i8,
    /// The channels it plays on, 1 to `MXR_V2IP_TONE_CHANNELS_MAX`; a line-up
    /// tone needs 2 or more.
    pub channels: u8,
    /// The frequency, `MXR_V2IP_TONE_FREQ_MIN` to `MXR_V2IP_TONE_FREQ_MAX` Hz.
    pub freq: u16,
    /// The sample rate: 44100, 48000 or 96000 Hz.
    pub rate: u32,
}

/// A V2IP sink's lip-sync flash: a pattern frame is marked every `period`,
/// the frame `lead` after a mark flashes white, and a beep tone starts
/// `offset` sample periods after it.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_test_sync_t {
    /// Every this many pattern frames is marked, 0 for none.
    pub period: u16,
    /// The frame this many after a mark flashes; below `period`, or 0 without
    /// one.
    pub lead: u16,
    /// Sample periods between a mark and the beep, at most
    /// `MXR_V2IP_SYNC_OFFSET_MAX`.
    pub offset: u32,
    /// How long the beep lasts, `MXR_V2IP_SYNC_BEEP_MS_MIN` to
    /// `MXR_V2IP_SYNC_BEEP_MS_MAX` ms.
    pub beep_ms: u16,
}

/// The test card a V2IP sink last reported. The counters run free and wrap.
#[repr(C)]
#[derive(Clone, Copy)]
pub struct mxr_v2ip_testcard_t {
    /// `MXR_V2IP_TESTCARD_*` bits.
    pub flags: u8,
    /// `MXR_V2IP_TEST_PATTERN_*`.
    pub pattern: u8,
    /// The colour of a flat pattern, `0xRRGGBB`.
    pub colour: u32,
    /// The tone.
    pub tone: mxr_v2ip_test_tone_t,
    /// The lip-sync flash.
    pub sync: mxr_v2ip_test_sync_t,
    /// Pattern frames sent.
    pub frames: u32,
    /// Sample periods since the tone started.
    pub periods: u32,
    /// Lip-sync marks the tone has seen.
    pub marks: u32,
}

/// The lowest test tone frequency, in Hz.
pub const MXR_V2IP_TONE_FREQ_MIN: u16 = 20;
/// The highest test tone frequency, in Hz.
pub const MXR_V2IP_TONE_FREQ_MAX: u16 = 20000;
/// The quietest test tone level, in dBFS.
pub const MXR_V2IP_TONE_LEVEL_MIN: i8 = -60;
/// The most channels a test tone plays on.
pub const MXR_V2IP_TONE_CHANNELS_MAX: u8 = 8;
/// The largest lip-sync beep offset, in sample periods.
pub const MXR_V2IP_SYNC_OFFSET_MAX: u32 = 0xFFFFFF;
/// The shortest lip-sync beep, in milliseconds.
pub const MXR_V2IP_SYNC_BEEP_MS_MIN: u16 = 1;
/// The longest lip-sync beep, in milliseconds.
pub const MXR_V2IP_SYNC_BEEP_MS_MAX: u16 = 10000;

const _: () = assert!(MXR_V2IP_TONE_FREQ_MIN == mx_remote::V2IP_TONE_FREQ_MIN);
const _: () = assert!(MXR_V2IP_TONE_FREQ_MAX == mx_remote::V2IP_TONE_FREQ_MAX);
const _: () = assert!(MXR_V2IP_TONE_LEVEL_MIN == mx_remote::V2IP_TONE_LEVEL_MIN);
const _: () = assert!(MXR_V2IP_TONE_CHANNELS_MAX == mx_remote::V2IP_TONE_CHANNELS_MAX);
const _: () = assert!(MXR_V2IP_SYNC_OFFSET_MAX == mx_remote::V2IP_SYNC_OFFSET_MAX);
const _: () = assert!(MXR_V2IP_SYNC_BEEP_MS_MIN == mx_remote::V2IP_SYNC_BEEP_MS_MIN);
const _: () = assert!(MXR_V2IP_SYNC_BEEP_MS_MAX == mx_remote::V2IP_SYNC_BEEP_MS_MAX);

impl From<V2ipTestTone> for mxr_v2ip_test_tone_t {
    fn from(t: V2ipTestTone) -> Self {
        Self {
            mode: t.mode.to_wire(),
            level: t.level,
            channels: t.channels,
            freq: t.freq,
            rate: t.rate,
        }
    }
}

impl From<mxr_v2ip_test_tone_t> for V2ipTestTone {
    fn from(t: mxr_v2ip_test_tone_t) -> Self {
        Self {
            mode: V2ipToneMode::from_wire(t.mode),
            freq: t.freq,
            level: t.level,
            channels: t.channels,
            rate: t.rate,
        }
    }
}

impl From<V2ipTestSync> for mxr_v2ip_test_sync_t {
    fn from(s: V2ipTestSync) -> Self {
        Self {
            period: s.period,
            lead: s.lead,
            offset: s.offset,
            beep_ms: s.beep_ms,
        }
    }
}

impl From<mxr_v2ip_test_sync_t> for V2ipTestSync {
    fn from(s: mxr_v2ip_test_sync_t) -> Self {
        Self {
            period: s.period,
            lead: s.lead,
            offset: s.offset,
            beep_ms: s.beep_ms,
        }
    }
}

/// Fills `out` with the test card a V2IP sink last reported.
///
/// Reports `MXR_ERR_NOT_REPORTED` until the sink has answered
/// `mxr_request_v2ip_testcard()` or a change. A change is announced through
/// `on_device_update`.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `mxr_v2ip_testcard_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_testcard(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_v2ip_testcard_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .v2ip_testcard(uid.into())
            .map(|t: V2ipTestcard| mxr_v2ip_testcard_t {
                flags: t.flags.bits(),
                pattern: t.pattern.to_wire(),
                colour: t.colour,
                tone: t.tone.into(),
                sync: t.sync.into(),
                frames: t.frames,
                periods: t.periods,
                marks: t.marks,
            });
        // SAFETY: the caller guarantees a writable struct or null.
        unsafe { fill(r, uid, out, "test card", value) }
    })
}

/// Fills `out` with the window a sink is told to show.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// [`mxr_tiling_config_t`].
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_tiling(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_tiling_config_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value =
            r.remote
                .v2ip_tiling(uid.into())
                .map(|t: V2ipTilingConfig| mxr_tiling_config_t {
                    target: t.target.into(),
                    pos_x: t.pos_x,
                    pos_y: t.pos_y,
                    width: t.width,
                    height: t.height,
                });
        // SAFETY: the caller guarantees a writable mxr_tiling_config_t or null.
        unsafe { fill(r, uid, out, "window", value) }
    })
}

/// Fills `out` with what a multiviewer reports about itself.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// [`mxr_multiviewer_status_t`].
#[no_mangle]
pub unsafe extern "C" fn mxr_multiviewer_status(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_multiviewer_status_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r.remote.multiviewer_status(uid.into()).map(multiviewer_of);
        // SAFETY: the caller guarantees a writable mxr_multiviewer_status_t or null.
        unsafe { fill(r, uid, out, "multiviewer status", value) }
    })
}

/// Copies a multiviewer's report into the C shape.
fn multiviewer_of(s: MultiviewerStatus) -> mxr_multiviewer_status_t {
    let mut out = mxr_multiviewer_status_t {
        uid: s.uid.into(),
        mappings: [mxr_uid_t::default(); MXR_MULTIVIEWER_INPUTS],
        mcu_version: [0; MXR_NAME_LEN],
        scaler_version: [0; MXR_NAME_LEN],
        hw_view_mode: s.hw_view_mode,
        view_mode: s.view_mode.to_wire(),
        pip_position: s.pip_position.to_wire(),
        pip_size: s.pip_size.to_wire(),
        output_mode: s.output_mode.to_wire(),
        hdcp_mode: s.hdcp_mode.to_wire(),
        output_itc: s.output_itc.to_wire(),
        edid_template: s.edid_template.to_wire(),
        screen_mode: s.screen_mode,
        aspect_ratio: s.aspect_ratio.to_wire(),
        auto_switch: s.auto_switch.to_wire(),
        audio_source: s.audio_source.to_wire(),
        has_audio_volume: s.audio_volume.is_some(),
        audio_volume: s.audio_volume.unwrap_or(0),
        audio_muted: s.audio_muted.to_wire(),
        video_sources: [0; MXR_MULTIVIEWER_INPUTS],
        remote_control: s.remote_control.to_wire(),
    };
    for (slot, uid) in out.mappings.iter_mut().zip(s.mappings) {
        *slot = uid.into();
    }
    for (slot, source) in out.video_sources.iter_mut().zip(s.video_sources) {
        *slot = source.to_wire();
    }
    put_str(&mut out.mcu_version, &s.mcu_version);
    put_str(&mut out.scaler_version, &s.scaler_version);
    out
}

/// Fills `out` with a ProAmp8's Dolby settings.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// [`mxr_dolby_settings_t`].
#[no_mangle]
pub unsafe extern "C" fn mxr_dolby_settings(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_dolby_settings_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r
            .remote
            .dolby_settings(uid.into())
            .map(mxr_dolby_settings_t::from);
        // SAFETY: the caller guarantees a writable mxr_dolby_settings_t or null.
        unsafe { fill(r, uid, out, "Dolby settings", value) }
    })
}

/// Fills `out` with a source bay's remote-control configuration.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// [`mxr_rc_settings_t`].
#[no_mangle]
pub unsafe extern "C" fn mxr_rc_settings(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_rc_settings_t,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        let value = r.remote.rc_settings(uid.into()).map(rc_settings_of);
        // SAFETY: the caller guarantees a writable mxr_rc_settings_t or null.
        unsafe { fill(r, uid, out, "remote-control configuration", value) }
    })
}

/// Copies a remote-control configuration into the C shape.
fn rc_settings_of(s: RcSettings) -> mxr_rc_settings_t {
    let mut out = mxr_rc_settings_t {
        target: s.target.into(),
        rc_target: s.rc_target,
        ip: [0; MXR_IP_STRING_LEN],
        cec_enabled: s.cec_enabled,
        cec_auto_on: s.cec_auto_on,
        forward_rc: s.forward_rc,
        forward_ir: s.forward_ir,
        rc_status: s.rc_status,
        status_name: [0; MXR_NAME_LEN],
    };
    put_ip(&mut out.ip, s.ip);
    put_str(&mut out.status_name, &s.status_name);
    out
}

/// Writes the streams a device's source bays advertise, and returns how many
/// there are.
///
/// Returns the full count even when it exceeds `cap`, so calling with `cap`
/// zero sizes the buffer.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` is null or points at `cap`
/// writable [`mxr_stream_sources_t`].
#[no_mangle]
pub unsafe extern "C" fn mxr_v2ip_sources(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_stream_sources_t,
    cap: usize,
) -> usize {
    guard(0, || {
        // SAFETY: the caller guarantees a live handle or null.
        let Some(r) = (unsafe { remote.as_ref() }) else {
            return no_handle();
        };
        let Some(sources) = r.remote.v2ip_sources(uid.into()) else {
            not_reported(r, uid, "V2IP stream sources");
            return 0;
        };
        // SAFETY: the caller guarantees cap writable elements at out.
        unsafe { copy_into(&sources, out, cap) }
    })
}

/// Writes a device's network ports, and returns how many there are.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` is null or points at `cap`
/// writable [`mxr_network_port_t`].
#[no_mangle]
pub unsafe extern "C" fn mxr_network_status(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_network_port_t,
    cap: usize,
) -> usize {
    guard(0, || {
        // SAFETY: the caller guarantees a live handle or null.
        let Some(r) = (unsafe { remote.as_ref() }) else {
            return no_handle();
        };
        let ports: Vec<mxr_network_port_t> = r
            .remote
            .network_status(uid.into())
            .iter()
            .map(port_of)
            .collect();
        // SAFETY: the caller guarantees cap writable elements at out.
        unsafe { copy_into(&ports, out, cap) }
    })
}

/// Copies one port report into the C shape.
fn port_of(p: &NetworkPortStatus) -> mxr_network_port_t {
    let errors = p.errors.unwrap_or_default();
    let mut out = mxr_network_port_t {
        port: p.port,
        name: [0; MXR_NAME_LEN],
        link_speed: p.link_speed.to_wire(),
        link_full_duplex: p.link_full_duplex,
        ip: [0; MXR_IP_STRING_LEN],
        querier: [0; MXR_IP_STRING_LEN],
        has_mac_address: p.mac_address.is_some(),
        mac_address: p.mac_address.unwrap_or_default().0,
        has_errors: p.errors.is_some(),
        in_error: errors.in_error,
        in_fcs_error: errors.in_fcs_error,
        in_collision: errors.in_collision,
        out_deferred: errors.out_deferred,
        out_excessive: errors.out_excessive,
        polarity_error: errors.polarity_error,
        skew_warning: errors.skew_warning,
        length_warning: errors.length_warning,
        has_vct_status: p.vct_status.is_some(),
        vct_warning: [false; MXR_UTP_PAIRS],
        cable_status_count: p.cable_status.len().min(MXR_UTP_PAIRS),
        cable_status: [mxr_cable_status_t {
            polarity: false,
            pair: 0,
            skew: 0,
            length: 0,
        }; MXR_UTP_PAIRS],
    };
    put_str(&mut out.name, &p.name);
    put_ip(&mut out.ip, p.ip);
    put_ip(&mut out.querier, p.querier);
    if let Some(vct) = p.vct_status {
        for (slot, status) in out.vct_warning.iter_mut().zip(vct) {
            *slot = status == VctStatus::Warning;
        }
    }
    for (slot, cable) in out.cable_status.iter_mut().zip(&p.cable_status) {
        *slot = (*cable).into();
    }
    out
}

/// Writes a device's view of the mesh topology, and returns how many entries
/// there are.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` is null or points at `cap`
/// writable [`mxr_topology_entry_t`].
#[no_mangle]
pub unsafe extern "C" fn mxr_topology(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_topology_entry_t,
    cap: usize,
) -> usize {
    guard(0, || {
        // SAFETY: the caller guarantees a live handle or null.
        let Some(r) = (unsafe { remote.as_ref() }) else {
            return no_handle();
        };
        let topology = r.remote.topology(uid.into());
        // SAFETY: the caller guarantees cap writable elements at out.
        unsafe { copy_into(&topology, out, cap) }
    })
}

/// Writes the firmware versions a device reports, and returns how many there
/// are.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` is null or points at `cap`
/// writable [`mxr_firmware_version_t`].
#[no_mangle]
pub unsafe extern "C" fn mxr_device_firmware(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_firmware_version_t,
    cap: usize,
) -> usize {
    guard(0, || {
        // SAFETY: the caller guarantees a live handle or null.
        let Some(r) = (unsafe { remote.as_ref() }) else {
            return no_handle();
        };
        let versions: Vec<mxr_firmware_version_t> = r
            .remote
            .firmware(uid.into())
            .iter()
            .map(|(_, v)| firmware_of(v))
            .collect();
        // SAFETY: the caller guarantees cap writable elements at out.
        unsafe { copy_into(&versions, out, cap) }
    })
}

/// Copies one firmware report into the C shape.
fn firmware_of(v: &FirmwareVersion) -> mxr_firmware_version_t {
    let mut out = mxr_firmware_version_t {
        firmware_type: v.firmware_type.to_wire(),
        timestamp: v.timestamp,
        hash: v.hash,
        version: [0; MXR_VERSION_LEN],
    };
    put_str(&mut out.version, &v.version);
    out
}

/// Writes a device's audio endpoints, in the order it reported them, and
/// returns how many there are.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` is null or points at `cap`
/// writable [`mxr_audio_endpoint_t`].
#[no_mangle]
pub unsafe extern "C" fn mxr_audio_endpoints(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    out: *mut mxr_audio_endpoint_t,
    cap: usize,
) -> usize {
    guard(0, || {
        // SAFETY: the caller guarantees a live handle or null.
        let Some(r) = (unsafe { remote.as_ref() }) else {
            return no_handle();
        };
        let Some(endpoints) = r.remote.audio_endpoints(uid.into()) else {
            not_reported(r, uid, "audio endpoints");
            return 0;
        };
        let list: Vec<mxr_audio_endpoint_t> = endpoints.list().map(Into::into).collect();
        // SAFETY: the caller guarantees cap writable elements at out.
        unsafe { copy_into(&list, out, cap) }
    })
}

/// Fills `out` with the state an audio endpoint reports, on the bits of its
/// features: `MXR_AUDIO_MUTE` while it is muted, `MXR_AUDIO_TRIGGER` while
/// its trigger is active, and `MXR_AUDIO_AUDIO_LOCK` while its source is
/// locked. Beside `mxr_audio_endpoint_t` rather than in it, so that struct
/// keeps its size.
///
/// Reports `MXR_ERR_NOT_REPORTED` until the device has reported its audio
/// endpoints, and `MXR_ERR_NOT_FOUND` for an endpoint it did not report.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` points at a writable
/// `uint32_t`.
#[no_mangle]
pub unsafe extern "C" fn mxr_audio_endpoint_status(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    endpoint: u8,
    out: *mut u32,
) -> mxr_result_t {
    // SAFETY: the caller guarantees a live handle or null.
    let handle = unsafe { remote.as_ref() };
    with(handle, |r| {
        if out.is_null() {
            return null_out("audio endpoint status");
        }
        let Some(endpoints) = r.remote.audio_endpoints(uid.into()) else {
            return not_reported(r, uid, "audio endpoints");
        };
        let Some(status) = endpoints.status(endpoint) else {
            return fail(
                mxr_result_t::MXR_ERR_NOT_FOUND,
                "the device reported no such audio endpoint",
            );
        };
        // SAFETY: the caller guarantees a writable uint32_t or null.
        unsafe { fill(r, uid, out, "audio endpoint status", Some(status.bits())) }
    })
}

/// Writes the endpoints hanging off one audio endpoint, and returns how many
/// there are.
///
/// # Safety
///
/// `remote` is null or a live handle, and `out` is null or points at `cap`
/// writable bytes.
#[no_mangle]
pub unsafe extern "C" fn mxr_audio_endpoint_children(
    remote: *const mxr_remote_t,
    uid: mxr_uid_t,
    endpoint: u8,
    out: *mut u8,
    cap: usize,
) -> usize {
    guard(0, || {
        // SAFETY: the caller guarantees a live handle or null.
        let Some(r) = (unsafe { remote.as_ref() }) else {
            return no_handle();
        };
        let children = match r.remote.audio_endpoints(uid.into()) {
            Some(endpoints) => match endpoints.get(endpoint) {
                Some(e) => e.children.clone(),
                None => {
                    fail(
                        mxr_result_t::MXR_ERR_NOT_FOUND,
                        &format!("the device has no audio endpoint {endpoint}"),
                    );
                    return 0;
                }
            },
            None => {
                not_reported(r, uid, "audio endpoints");
                return 0;
            }
        };
        // SAFETY: the caller guarantees cap writable bytes at out.
        unsafe { copy_into(&children, out, cap) }
    })
}

/// Reports a null handle from a call whose answer is a count.
fn no_handle() -> usize {
    fail(
        mxr_result_t::MXR_ERR_INVALID_ARGUMENT,
        "the client handle is null",
    );
    0
}

#[cfg(test)]
mod tests {
    use std::ffi::CStr;
    use std::net::Ipv4Addr;

    use mx_remote::V2ipPrivacyStream;

    use super::privacy_stream;

    /// Each field lands in its own C field, every one of them distinct.
    #[test]
    fn a_privacy_stream_keeps_every_field() {
        let s = V2ipPrivacyStream {
            group: Ipv4Addr::new(239, 1, 2, 3),
            port: 0x1388,
            version: 7,
            on: true,
            full_id: 3,
            short_id: 4,
            iv: [0x10; 8],
            key_generator: [0x20; 16],
            key_id: [0x30; 8],
            key_version: 0x0102_0304,
        };
        let c = privacy_stream(&s);
        // SAFETY: put_ip writes a NUL-terminated string into the array.
        let group = unsafe { CStr::from_ptr(c.group.as_ptr()) };
        assert_eq!(group.to_str(), Ok("239.1.2.3"));
        assert_eq!((c.port, c.version, c.on), (0x1388, 7, true));
        assert_eq!((c.full_id, c.short_id), (3, 4));
        assert_eq!(
            (c.iv, c.key_generator, c.key_id),
            (s.iv, s.key_generator, s.key_id)
        );
        assert_eq!(c.key_version, 0x0102_0304);
    }
}