pub mod discovery;
pub mod proto;
mod runner;
pub mod stream;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;
use fast_talker::options::{SocketOption, ThreadOption};
use parking_lot::Mutex;
use crate::error::{CameraError, Result};
use crate::gige::proto::bootstrap;
use crate::gige::proto::gvcp;
use crate::gige::proto::gvsp;
use crate::gige::runner::ToWorker;
use crate::gige::stream::{StreamChannel, StreamConfig, StreamShared};
use crate::handle::{ResponseHandle, unwrap_arc};
use crate::link::{LinkCounters, LinkStats as HealthStats};
use crate::thread_util::ThreadHandle;
use crate::tuning::{self, SocketRole, TuningReport};
use crate::wire::{
ControlRx, ControlTelemetry, ControlTx, GvcpCmd, GvspPacket, StreamTelemetry, TelemetrySink,
};
pub use proto::bootstrap::DeviceInfo;
pub use proto::gvcp::GvcpStatus;
pub use proto::gvsp::PixelFormat;
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct GigeConfig {
pub addr: SocketAddr,
pub local_addr: Option<SocketAddr>,
pub gvcp_timeout: Duration,
pub retries: u8,
pub heartbeat_timeout_ms: u32,
pub exclusive: bool,
pub event_capacity: usize,
pub thread: Vec<ThreadOption>,
pub control_socket: Vec<SocketOption>,
}
impl GigeConfig {
pub fn new(ip: impl Into<IpAddr>) -> Self {
Self {
addr: SocketAddr::new(ip.into(), gvcp::GVCP_PORT),
local_addr: None,
gvcp_timeout: Duration::from_millis(500),
retries: 4,
heartbeat_timeout_ms: 3000,
exclusive: false,
event_capacity: 64,
thread: Vec::new(),
control_socket: Vec::new(),
}
}
pub(crate) fn transaction_budget(&self) -> Duration {
self.gvcp_timeout * (u32::from(self.retries) + 1) + Duration::from_millis(500)
}
}
#[cfg_attr(feature = "valuable", derive(valuable::Valuable))]
#[derive(Debug, Clone, Copy, Default, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "py", pyo3::pyclass(get_all, skip_from_py_object))]
pub struct LinkStats {
pub commands: u64,
pub acks: u64,
pub retries: u64,
pub timeouts: u64,
pub naks: u64,
pub pending_acks: u64,
pub heartbeats: u64,
pub events: u64,
pub unsolicited: u64,
}
#[cfg_attr(feature = "valuable", derive(valuable::Valuable))]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct GvcpEvent {
pub command: u16,
pub event_id: u16,
pub stream_channel: u16,
pub block_id: u16,
pub timestamp: u64,
pub data: Vec<u8>,
pub raw: Vec<u8>,
}
impl GvcpEvent {
pub(crate) fn parse(command: u16, payload: &[u8]) -> Self {
let u16_at = |i: usize| {
payload
.get(i..i + 2)
.map_or(0, |b| u16::from_be_bytes([b[0], b[1]]))
};
let timestamp = payload.get(8..16).map_or(0, |b| {
u64::from_be_bytes([b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]])
});
Self {
command,
event_id: u16_at(2),
stream_channel: u16_at(4),
block_id: u16_at(6),
timestamp,
data: payload.get(16..).unwrap_or_default().to_vec(),
raw: payload.to_vec(),
}
}
}
#[derive(Debug, Clone)]
pub struct EventChannel {
rx: flume::Receiver<GvcpEvent>,
}
impl EventChannel {
pub fn wait_for(&self, timeout: Duration) -> Option<GvcpEvent> {
self.rx.recv_timeout(timeout).ok()
}
pub fn try_recv(&self) -> Option<GvcpEvent> {
self.rx.try_recv().ok()
}
pub fn is_disconnected(&self) -> bool {
self.rx.is_disconnected()
}
pub async fn recv_async(&self) -> Option<GvcpEvent> {
self.rx.recv_async().await.ok()
}
}
pub(crate) struct Shared {
pub(crate) stats: Mutex<LinkStats>,
pub(crate) link: Arc<LinkCounters>,
control_lost: AtomicBool,
concatenation: AtomicBool,
}
impl Shared {
fn new(link: Arc<LinkCounters>) -> Self {
Self {
stats: Mutex::new(LinkStats::default()),
link,
control_lost: AtomicBool::new(false),
concatenation: AtomicBool::new(false),
}
}
pub(crate) fn set_control_lost(&self) {
self.control_lost.store(true, Ordering::Relaxed);
}
fn control_lost(&self) -> bool {
self.control_lost.load(Ordering::Relaxed)
}
pub(crate) fn concatenation(&self) -> bool {
self.concatenation.load(Ordering::Relaxed)
}
}
pub(crate) struct ControlPort {
to_worker: flume::Sender<ToWorker>,
thread: ThreadHandle,
budget: Duration,
}
impl Clone for ControlPort {
fn clone(&self) -> Self {
Self {
to_worker: self.to_worker.clone(),
thread: self.thread.to_pass_in(),
budget: self.budget,
}
}
}
impl ControlPort {
pub(crate) fn budget(&self) -> Duration {
self.budget
}
fn send(&self, msg: ToWorker) -> Result<()> {
if !self.thread.is_alive() {
return Err(CameraError::Disconnected);
}
self.to_worker
.send(msg)
.map_err(|_| CameraError::Disconnected)?;
self.thread.wake().ok();
if !self.thread.is_alive() {
return Err(CameraError::Disconnected);
}
Ok(())
}
fn submit<T: Clone>(
&self,
build: impl FnOnce(ResponseHandle<T>) -> ToWorker,
) -> ResponseHandle<T> {
let handle = ResponseHandle::new();
if let Err(e) = self.send(build(handle.clone())) {
handle.fail(e);
}
handle
}
pub(crate) fn read_register(&self, addr: u32) -> ResponseHandle<u32> {
self.submit(|h| ToWorker::ReadReg(addr, h))
}
pub(crate) fn read_registers(&self, addrs: Vec<u32>) -> ResponseHandle<Vec<u32>> {
self.submit(|h| ToWorker::ReadRegs(addrs, h))
}
pub(crate) fn write_register(&self, addr: u32, value: u32) -> ResponseHandle<()> {
tracing::trace!("write register {addr:#06x} := {value:#010x}");
self.submit(|h| ToWorker::WriteRegs(vec![(addr, value)], h))
}
pub(crate) fn write_registers(&self, pairs: Vec<(u32, u32)>) -> ResponseHandle<()> {
tracing::trace!(?pairs, "write registers");
self.submit(|h| ToWorker::WriteRegs(pairs, h))
}
pub(crate) fn read_memory(&self, addr: u32, len: u32) -> ResponseHandle<Vec<u8>> {
let handle = ResponseHandle::new();
if !addr.is_multiple_of(4) {
handle.fail(CameraError::Protocol(
"read address must be 4-byte aligned".into(),
));
return handle;
}
if let Err(e) = self.send(ToWorker::ReadMem {
addr,
len,
handle: handle.clone(),
}) {
handle.fail(e);
}
handle
}
pub(crate) fn write_memory(&self, addr: u32, data: Vec<u8>) -> ResponseHandle<()> {
tracing::trace!("write memory {addr:#06x} ({} bytes)", data.len());
let handle = ResponseHandle::new();
if !addr.is_multiple_of(4) || !data.len().is_multiple_of(4) {
handle.fail(CameraError::Protocol(
"write address and length must be 4-byte aligned".into(),
));
return handle;
}
if let Err(e) = self.send(ToWorker::WriteMem {
addr,
data,
handle: handle.clone(),
}) {
handle.fail(e);
}
handle
}
}
struct Connection {
port: ControlPort,
thread: ThreadHandle,
shared: Arc<Shared>,
device_addr: SocketAddr,
local_addr: SocketAddr,
info: DeviceInfo,
capabilities: u32,
genicam_xml: Option<Arc<[u8]>>,
genicam: Option<crate::genicam::Genicam>,
tuning: TuningReport,
}
pub struct GigECamera {
cfg: GigeConfig,
connection: Option<Connection>,
telemetry: Option<ControlTelemetry>,
link: Arc<LinkCounters>,
}
impl std::fmt::Debug for GigECamera {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GigECamera")
.field("addr", &self.cfg.addr)
.field("connected", &self.is_connected())
.field(
"model",
&self
.connection
.as_ref()
.map(|c| c.info.model.as_str())
.unwrap_or(""),
)
.finish()
}
}
impl GigECamera {
pub fn new(ip: impl Into<IpAddr>) -> Self {
Self::with_config(GigeConfig::new(ip))
}
pub fn with_config(cfg: GigeConfig) -> Self {
Self {
cfg,
connection: None,
telemetry: None,
link: Arc::new(LinkCounters::default()),
}
}
pub fn set_telemetry<S: TelemetrySink<ControlTx, ControlRx>>(&mut self, telemetry: S) {
self.telemetry = Some(Arc::new(telemetry));
}
pub fn config(&self) -> &GigeConfig {
&self.cfg
}
pub fn config_mut(&mut self) -> &mut GigeConfig {
&mut self.cfg
}
pub fn connect(&mut self) -> Result<()> {
if let Some(conn) = &self.connection {
if conn.thread.is_alive() {
return Ok(());
}
self.connection = None;
}
let conn = establish(self.cfg.clone(), self.telemetry.clone(), self.link.clone())?;
tracing::debug!(
addr = %conn.device_addr,
model = %conn.info.model,
serial = %conn.info.serial,
"connected"
);
self.connection = Some(conn);
Ok(())
}
pub fn disconnect(&mut self, deadline: Duration) {
let Some(conn) = self.connection.take() else {
return;
};
tracing::debug!(addr = %conn.device_addr, "disconnecting");
if conn.port.send(ToWorker::Shutdown).is_ok() {
conn.thread.wait_exited(deadline);
}
conn.thread.request_stop();
}
pub fn is_connected(&self) -> bool {
self.connection
.as_ref()
.is_some_and(|c| c.thread.is_alive())
}
fn conn(&self) -> Result<&Connection> {
match &self.connection {
None => Err(CameraError::Disconnected),
Some(c) if !c.thread.is_alive() => Err(if c.shared.control_lost() {
CameraError::ControlLost
} else {
CameraError::Disconnected
}),
Some(c) => Ok(c),
}
}
fn conn_mut(&mut self) -> Result<&mut Connection> {
self.conn()?;
match &mut self.connection {
Some(c) => Ok(c),
None => Err(CameraError::Disconnected),
}
}
pub fn read_register(&self, addr: u32) -> Result<ResponseHandle<u32>> {
Ok(self.conn()?.port.read_register(addr))
}
pub fn read_registers(&self, addrs: Vec<u32>) -> Result<ResponseHandle<Vec<u32>>> {
Ok(self.conn()?.port.read_registers(addrs))
}
pub fn write_register(&self, addr: u32, value: u32) -> Result<ResponseHandle<()>> {
Ok(self.conn()?.port.write_register(addr, value))
}
pub fn write_registers(&self, pairs: Vec<(u32, u32)>) -> Result<ResponseHandle<()>> {
Ok(self.conn()?.port.write_registers(pairs))
}
pub fn read_memory(&self, addr: u32, len: u32) -> Result<ResponseHandle<Vec<u8>>> {
Ok(self.conn()?.port.read_memory(addr, len))
}
pub fn write_memory(&self, addr: u32, data: Vec<u8>) -> Result<ResponseHandle<()>> {
Ok(self.conn()?.port.write_memory(addr, data))
}
pub fn device_info(&self) -> Result<&DeviceInfo> {
Ok(&self.conn()?.info)
}
pub fn capabilities(&self) -> Result<u32> {
Ok(self.conn()?.capabilities)
}
pub fn events(&self) -> Result<EventChannel> {
let conn = self.conn()?;
let (tx, rx) = flume::bounded(self.cfg.event_capacity);
conn.port.send(ToWorker::SubscribeEvents(tx))?;
Ok(EventChannel { rx })
}
pub fn enable_events(&self) -> Result<()> {
let conn = self.conn()?;
if conn.capabilities & bootstrap::CAP_EVENT == 0 {
return Err(CameraError::Unsupported("message channel events"));
}
let IpAddr::V4(host_v4) = advertised_host_ip(conn)? else {
return Err(CameraError::Unsupported(
"IPv6 message channel destinations",
));
};
for (addr, value) in [
(bootstrap::MESSAGE_CHANNEL_DEST_ADDRESS, u32::from(host_v4)),
(bootstrap::MESSAGE_CHANNEL_TRANSMISSION_TIMEOUT, 1000),
(bootstrap::MESSAGE_CHANNEL_RETRY_COUNT, 3),
(
bootstrap::MESSAGE_CHANNEL_PORT,
u32::from(conn.local_addr.port()),
),
] {
conn.port
.write_register(addr, value)
.wait_timeout(conn.port.budget())
.map_err(unwrap_arc)?;
}
Ok(())
}
pub fn disable_events(&self) -> Result<()> {
let conn = self.conn()?;
conn.port
.write_register(bootstrap::MESSAGE_CHANNEL_PORT, 0)
.wait_timeout(conn.port.budget())
.map_err(unwrap_arc)?;
Ok(())
}
pub fn stats(&self) -> Option<LinkStats> {
self.connection.as_ref().map(|c| *c.shared.stats.lock())
}
pub fn link_stats(&self) -> HealthStats {
self.link.snapshot()
}
pub fn tuning_report(&self) -> Option<&TuningReport> {
self.connection.as_ref().map(|c| &c.tuning)
}
pub fn open_stream(&self, cfg: StreamConfig) -> Result<StreamChannel> {
self.open_stream_inner(cfg, None)
}
pub fn open_stream_with_telemetry<S: TelemetrySink<GvcpCmd, GvspPacket>>(
&self,
cfg: StreamConfig,
telemetry: S,
) -> Result<StreamChannel> {
self.open_stream_inner(cfg, Some(Arc::new(telemetry)))
}
fn open_stream_inner(
&self,
cfg: StreamConfig,
telemetry: Option<StreamTelemetry>,
) -> Result<StreamChannel> {
let payload_size = cfg
.payload_size
.filter(|&n| n > 0)
.ok_or_else(|| CameraError::Protocol("payload_size must be set".into()))?;
tuning::check_thread(tuning::ThreadRole::Stream, &cfg.thread)?;
tuning::check_socket(SocketRole::UdpStreamRx, &cfg.stream_socket)?;
let conn = self.conn()?;
let port = &conn.port;
let budget = port.budget();
let base = cfg.channel_base();
let local = match cfg.local_addr {
Some(a) => a,
None => SocketAddr::new(advertised_host_ip(conn)?, 0),
};
let (socket, socket_report) =
tuning::bind_udp(SocketRole::UdpStreamRx, local, &cfg.stream_socket_options())
.map_err(std::io::Error::from)?;
let bound = socket.local_addr()?;
let IpAddr::V4(host_v4) = bound.ip() else {
return Err(CameraError::Unsupported("IPv6 stream destinations"));
};
if host_v4.is_unspecified() {
tracing::debug!(
local = %bound,
"stream host IP unresolved; advertising SCDA=0 (device streams to the GVCP requester)"
);
}
port.write_register(
bootstrap::STREAM_CHANNEL_DEST_ADDRESS + base,
u32::from(host_v4),
)
.wait_timeout(budget)
.map_err(unwrap_arc)?;
port.write_register(
bootstrap::STREAM_CHANNEL_PORT + base,
u32::from(bound.port()),
)
.wait_timeout(budget)
.map_err(unwrap_arc)?;
let open = move || -> Result<StreamChannel> {
let scps_addr = bootstrap::STREAM_CHANNEL_PACKET_SIZE + base;
let packet_size = match cfg.packet_size {
crate::gige::stream::PacketSize::Fixed(n) => {
port.write_register(scps_addr, u32::from(n))
.wait_timeout(budget)
.map_err(unwrap_arc)?;
n
}
crate::gige::stream::PacketSize::Auto => {
negotiate_packet_size(port, conn.device_addr.ip(), &socket, scps_addr)?
}
};
if let Some(delay) = cfg.packet_delay {
port.write_register(bootstrap::STREAM_CHANNEL_PACKET_DELAY + base, delay)
.wait_timeout(budget)
.map_err(unwrap_arc)?;
}
let tick_frequency = port
.read_registers(vec![
bootstrap::TIMESTAMP_TICK_FREQUENCY_HIGH,
bootstrap::TIMESTAMP_TICK_FREQUENCY_LOW,
])
.wait_timeout(budget)
.map(|v| (u64::from(v[0]) << 32) | u64::from(v[1]))
.unwrap_or(0);
let resend_enabled = cfg.resend == crate::gige::stream::ResendPolicy::Always
&& conn.capabilities & bootstrap::CAP_PACKET_RESEND != 0;
let shared = Arc::new(StreamShared {
stats: Mutex::new(Default::default()),
link: self.link.clone(),
});
let (to_worker, rx) = flume::unbounded();
let channel = cfg.channel;
let (thread, thread_report) = crate::gige::stream::runner::spawn(
socket,
crate::gige::stream::runner::LinkParams {
device_gvcp_addr: conn.device_addr,
scps_packet_size: packet_size,
payload_size,
resend_enabled,
tick_frequency,
},
rx,
shared.clone(),
cfg,
telemetry,
)?;
tracing::debug!(channel, local = %bound, packet_size, "stream channel opened");
Ok(StreamChannel {
to_worker,
thread,
shared,
control: port.clone(),
channel_base: base,
packet_size,
local_addr: bound,
tuning: TuningReport {
thread: thread_report,
socket: socket_report.summary(),
},
})
};
open().inspect_err(|_| {
let _ = port
.write_register(bootstrap::STREAM_CHANNEL_PORT + base, 0)
.wait_timeout(budget);
})
}
pub fn genicam_xml(&mut self) -> Result<Arc<[u8]>> {
let conn = self.conn_mut()?;
if let Some(xml) = &conn.genicam_xml {
return Ok(xml.clone());
}
let mut last_err = CameraError::Protocol("no GenICam URL".into());
for url_addr in [bootstrap::XML_URL_0, bootstrap::XML_URL_1] {
match fetch_genicam_xml(&conn.port, url_addr) {
Ok(xml) => {
conn.genicam_xml = Some(xml.clone());
return Ok(xml);
}
Err(e) => {
tracing::debug!("GenICam URL at {url_addr:#x} failed: {e}");
last_err = e;
}
}
}
Err(last_err)
}
pub(crate) fn ensure_genicam(&mut self) -> crate::error::GenicamResult<()> {
if self.conn()?.genicam.is_some() {
return Ok(());
}
let xml = self.genicam_xml()?;
let text = String::from_utf8_lossy(&xml);
let graph = crate::genicam::parse_xml(&text)?;
tracing::debug!("GenICam feature model loaded");
self.conn_mut()?.genicam = Some(graph);
Ok(())
}
pub(crate) fn genicam_parts(
&mut self,
) -> crate::error::GenicamResult<(&mut crate::genicam::Genicam, &ControlPort)> {
let conn = self.conn_mut()?;
let Connection { genicam, port, .. } = conn;
match genicam {
Some(graph) => Ok((graph, port)),
None => Err(crate::error::GenicamError::Xml(
"feature model not loaded".into(),
)),
}
}
pub(crate) fn genicam_graph(&self) -> crate::error::GenicamResult<&crate::genicam::Genicam> {
self.conn()?
.genicam
.as_ref()
.ok_or_else(|| crate::error::GenicamError::Xml("feature model not loaded".into()))
}
pub(crate) fn genicam_ref(&self) -> Option<&crate::genicam::Genicam> {
self.connection.as_ref()?.genicam.as_ref()
}
}
fn advertised_host_ip(conn: &Connection) -> Result<IpAddr> {
if !conn.local_addr.ip().is_unspecified() {
return Ok(conn.local_addr.ip());
}
match fast_talker::nic::source_for(conn.device_addr.ip()) {
Err(e) if e.kind() == std::io::ErrorKind::AddrNotAvailable => {
Ok(Ipv4Addr::UNSPECIFIED.into())
}
found => Ok(found?),
}
}
fn establish(
cfg: GigeConfig,
telemetry: Option<ControlTelemetry>,
link: Arc<LinkCounters>,
) -> Result<Connection> {
let shared = Arc::new(Shared::new(link));
let (to_worker, rx) = flume::unbounded();
let (thread, local_addr, tuning) = runner::spawn(rx, shared.clone(), cfg.clone(), telemetry)?;
let port = ControlPort {
to_worker,
thread: thread.to_pass_in(),
budget: cfg.transaction_budget(),
};
let budget = port.budget();
let ccp = bootstrap::CCP_CONTROL
| if cfg.exclusive {
bootstrap::CCP_EXCLUSIVE
} else {
0
};
port.write_register(bootstrap::CONTROL_CHANNEL_PRIVILEGE, ccp)
.wait_timeout(budget)
.map_err(|e| match &*e {
CameraError::Nak { status, .. }
if *status == GvcpStatus::ACCESS_DENIED || *status == GvcpStatus::WRITE_PROTECT =>
{
CameraError::ControlDenied
}
CameraError::Timeout => CameraError::ConnectTimeout,
_ => unwrap_arc(e),
})?;
port.write_register(bootstrap::HEARTBEAT_TIMEOUT, cfg.heartbeat_timeout_ms)
.wait_timeout(budget)
.map_err(unwrap_arc)?;
let capabilities = port
.read_register(bootstrap::GVCP_CAPABILITY)
.wait_timeout(budget)
.map_err(unwrap_arc)?;
shared.concatenation.store(
capabilities & bootstrap::CAP_CONCATENATION != 0,
Ordering::Relaxed,
);
let info = fetch_device_info(&port)?;
Ok(Connection {
port,
thread,
shared,
device_addr: cfg.addr,
local_addr,
info,
capabilities,
genicam_xml: None,
genicam: None,
tuning,
})
}
fn fetch_device_info(port: &ControlPort) -> Result<DeviceInfo> {
let budget = port.budget();
let regs = port
.read_registers(vec![
bootstrap::VERSION,
bootstrap::DEVICE_MODE,
bootstrap::DEVICE_MAC_HIGH,
bootstrap::DEVICE_MAC_LOW,
bootstrap::SUPPORTED_IP_CONFIG,
bootstrap::CURRENT_IP_CONFIG,
bootstrap::CURRENT_IP_ADDRESS,
bootstrap::CURRENT_SUBNET_MASK,
bootstrap::CURRENT_GATEWAY,
])
.wait_timeout(budget)
.map_err(unwrap_arc)?;
let [
version,
device_mode,
mac_high,
mac_low,
supported_ip_config,
current_ip_config,
ip,
mask,
gateway,
] = regs[..]
else {
return Err(CameraError::Protocol(
"short bootstrap register read".into(),
));
};
let string_field = |addr: u32, size: usize| -> Result<String> {
match port.read_memory(addr, size as u32).wait_timeout(budget) {
Ok(raw) => {
let end = raw.iter().position(|&b| b == 0).unwrap_or(raw.len());
Ok(String::from_utf8_lossy(&raw[..end]).into_owned())
}
Err(e) if matches!(&*e, CameraError::Nak { .. }) => {
tracing::trace!("string register {addr:#06x} unreadable: {e}");
Ok(String::new())
}
Err(e) => Err(unwrap_arc(e)),
}
};
let mut mac = [0u8; 6];
mac[..2].copy_from_slice(&mac_high.to_be_bytes()[2..]);
mac[2..].copy_from_slice(&mac_low.to_be_bytes());
Ok(DeviceInfo {
spec_version: ((version >> 16) as u16, version as u16),
device_mode,
mac,
supported_ip_config,
current_ip_config,
ip: ip.into(),
subnet_mask: mask.into(),
gateway: gateway.into(),
manufacturer: string_field(
bootstrap::MANUFACTURER_NAME,
bootstrap::MANUFACTURER_NAME_SIZE,
)?,
model: string_field(bootstrap::MODEL_NAME, bootstrap::MODEL_NAME_SIZE)?,
device_version: string_field(bootstrap::DEVICE_VERSION, bootstrap::DEVICE_VERSION_SIZE)?,
manufacturer_info: string_field(
bootstrap::MANUFACTURER_INFO,
bootstrap::MANUFACTURER_INFO_SIZE,
)?,
serial: string_field(bootstrap::SERIAL_NUMBER, bootstrap::SERIAL_NUMBER_SIZE)?,
user_defined_name: string_field(
bootstrap::USER_DEFINED_NAME,
bootstrap::USER_DEFINED_NAME_SIZE,
)?,
})
}
const MAX_XML_SIZE: usize = 64 << 20;
fn fetch_genicam_xml(port: &ControlPort, url_addr: u32) -> Result<Arc<[u8]>> {
let budget = port.budget();
let raw = port
.read_memory(url_addr, bootstrap::XML_URL_SIZE as u32)
.wait_timeout(budget * 2)
.map_err(unwrap_arc)?;
let end = raw.iter().position(|&b| b == 0).unwrap_or(raw.len());
let url_str = String::from_utf8_lossy(&raw[..end]);
let url = crate::genicam::XmlUrl::parse(&url_str).map_err(CameraError::Protocol)?;
let data = match &url {
crate::genicam::XmlUrl::Local { address, size, .. } => {
let address = u32::try_from(*address)
.map_err(|_| CameraError::Protocol("XML address beyond 32 bit".into()))?;
let size = u32::try_from(*size)
.ok()
.filter(|&s| s as usize <= MAX_XML_SIZE)
.ok_or_else(|| CameraError::Protocol(format!("XML size {size} out of range")))?;
let budget = budget * (size / 512 + 2);
port.read_memory(address, size)
.wait_timeout(budget)
.map_err(unwrap_arc)?
}
crate::genicam::XmlUrl::File(path) => std::fs::read(path)?,
crate::genicam::XmlUrl::Http(_) => {
return Err(CameraError::Unsupported("http-hosted GenICam XML"));
}
};
let data = if url.is_zip() {
crate::genicam::zip::extract_first_file(&data).map_err(CameraError::Protocol)?
} else {
data
};
Ok(Arc::from(data.into_boxed_slice()))
}
fn negotiate_packet_size(
port: &ControlPort,
device_ip: IpAddr,
socket: &std::net::UdpSocket,
scps_addr: u32,
) -> Result<u16> {
const INC: u16 = 16;
const MIN: u16 = 560;
const MAX: u16 = 9152;
let budget = port.budget();
socket
.set_read_timeout(Some(Duration::from_millis(25)))
.ok();
let mut buf = vec![0u8; 0x10000];
let mut probe = |size: u16| -> Option<u16> {
let value =
u32::from(size) | bootstrap::SCPS_FIRE_TEST_PACKET | bootstrap::SCPS_DO_NOT_FRAGMENT;
port.write_register(scps_addr, value)
.wait_timeout(budget)
.ok()?;
let mut achieved = None;
for _ in 0..3 {
match socket.recv_from(&mut buf) {
Ok((n, src)) if src.ip() == device_ip => {
let delivered = (n + gvsp::PACKET_UDP_OVERHEAD) as u16;
if delivered <= size {
achieved = achieved.max(Some(delivered));
if delivered == size {
break;
}
}
}
Ok(_) => {}
Err(_) => {}
}
}
achieved
};
let mut best = 0u16;
let size = if let Some(a) = probe(MAX) {
a
} else if let Some(mut good) = [1488u16, 1008, MIN].into_iter().find(|&c| match probe(c) {
Some(a) => {
best = best.max(a);
true
}
None => false,
}) {
let mut bad = MAX;
while bad - good > INC {
let mid = good + (bad - good) / 2 / INC * INC;
match probe(mid) {
Some(a) => {
best = best.max(a);
good = mid;
}
None => bad = mid,
}
}
best
} else {
tracing::warn!("packet size fire-test unsupported, falling back to 1500");
1500
};
let size = size.max(MIN);
port.write_register(scps_addr, u32::from(size))
.wait_timeout(budget)
.map_err(unwrap_arc)?;
socket.set_read_timeout(Some(Duration::from_millis(5))).ok();
while socket.recv_from(&mut buf).is_ok() {}
tracing::debug!("negotiated stream packet size {size}");
Ok(size)
}