716 lines
27 KiB
Rust
716 lines
27 KiB
Rust
// client/src/input/camera.rs
|
||
use anyhow::Context;
|
||
use gst::prelude::*;
|
||
use gstreamer as gst;
|
||
use gstreamer_app as gst_app;
|
||
use lesavka_common::lesavka::VideoPacket;
|
||
use std::{
|
||
io::Write,
|
||
path::{Path, PathBuf},
|
||
sync::{
|
||
Arc,
|
||
atomic::{AtomicBool, Ordering},
|
||
},
|
||
thread,
|
||
time::Duration,
|
||
};
|
||
|
||
const CAMERA_PREVIEW_TAP_ENV: &str = "LESAVKA_UPLINK_CAMERA_PREVIEW";
|
||
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||
enum CameraSourceProfile {
|
||
Raw,
|
||
Mjpeg,
|
||
AutoDecode,
|
||
}
|
||
|
||
fn env_u32(name: &str, default: u32) -> u32 {
|
||
std::env::var(name)
|
||
.ok()
|
||
.and_then(|v| v.parse::<u32>().ok())
|
||
.unwrap_or(default)
|
||
}
|
||
|
||
#[derive(Clone, Copy, Debug)]
|
||
pub enum CameraCodec {
|
||
H264,
|
||
Mjpeg,
|
||
}
|
||
|
||
#[derive(Clone, Copy, Debug)]
|
||
pub struct CameraConfig {
|
||
pub codec: CameraCodec,
|
||
pub width: u32,
|
||
pub height: u32,
|
||
pub fps: u32,
|
||
}
|
||
|
||
pub struct CameraCapture {
|
||
#[allow(dead_code)] // kept alive to hold PLAYING state
|
||
pipeline: gst::Pipeline,
|
||
sink: gst_app::AppSink,
|
||
preview_tap_running: Option<Arc<AtomicBool>>,
|
||
}
|
||
|
||
impl CameraCapture {
|
||
pub fn new(device_fragment: Option<&str>, cfg: Option<CameraConfig>) -> anyhow::Result<Self> {
|
||
gst::init().ok();
|
||
|
||
// Select source: V4L2 device or test pattern
|
||
let (src_desc, dev_label, allow_mjpg_source) = match device_fragment {
|
||
Some(fragment)
|
||
if fragment.eq_ignore_ascii_case("test")
|
||
|| fragment.eq_ignore_ascii_case("videotestsrc") =>
|
||
{
|
||
let pattern =
|
||
std::env::var("LESAVKA_CAM_TEST_PATTERN").unwrap_or_else(|_| "smpte".into());
|
||
(
|
||
format!("videotestsrc is-live=true pattern={pattern}"),
|
||
format!("videotestsrc:{pattern}"),
|
||
false,
|
||
)
|
||
}
|
||
Some(path) if path.starts_with("/dev/") => (
|
||
format!("v4l2src device={path} do-timestamp=true"),
|
||
path.to_string(),
|
||
true,
|
||
),
|
||
Some(fragment) => {
|
||
let dev = Self::find_device(fragment).unwrap_or_else(|| "/dev/video0".into());
|
||
(format!("v4l2src device={dev} do-timestamp=true"), dev, true)
|
||
}
|
||
None => {
|
||
let dev = "/dev/video0".to_string();
|
||
(format!("v4l2src device={dev} do-timestamp=true"), dev, true)
|
||
}
|
||
};
|
||
|
||
let output_mjpeg = cfg.map_or_else(
|
||
|| {
|
||
std::env::var("LESAVKA_CAM_CODEC").ok().is_some_and(|v| {
|
||
matches!(v.to_ascii_lowercase().as_str(), "mjpeg" | "mjpg" | "jpeg")
|
||
})
|
||
},
|
||
|cfg| matches!(cfg.codec, CameraCodec::Mjpeg),
|
||
);
|
||
let jpeg_quality = env_u32("LESAVKA_CAM_JPEG_QUALITY", 85).clamp(1, 100);
|
||
let width = env_u32("LESAVKA_CAM_WIDTH", cfg.map_or(1280, |cfg| cfg.width));
|
||
let height = env_u32("LESAVKA_CAM_HEIGHT", cfg.map_or(720, |cfg| cfg.height));
|
||
let fps = env_u32("LESAVKA_CAM_FPS", cfg.map_or(25, |cfg| cfg.fps)).max(1);
|
||
let keyframe_interval = env_u32("LESAVKA_CAM_KEYFRAME_INTERVAL", fps.min(5)).clamp(1, fps);
|
||
let source_profile = camera_source_profile(allow_mjpg_source);
|
||
let use_mjpg_source = source_profile == CameraSourceProfile::Mjpeg;
|
||
let (enc, kf_prop) = if use_mjpg_source && !output_mjpeg {
|
||
("x264enc", Some("key-int-max"))
|
||
} else {
|
||
Self::choose_encoder()
|
||
};
|
||
match source_profile {
|
||
CameraSourceProfile::Mjpeg if !output_mjpeg => {
|
||
tracing::info!("📸 using MJPG source with software encode");
|
||
}
|
||
CameraSourceProfile::AutoDecode => {
|
||
tracing::info!("📸 using auto-decoded webcam source (raw/MJPEG accepted)");
|
||
}
|
||
_ => {}
|
||
}
|
||
let enc_opts = Self::encoder_options(enc, kf_prop, keyframe_interval);
|
||
if output_mjpeg {
|
||
tracing::info!("📸 outputting MJPEG frames for UVC (quality={jpeg_quality})");
|
||
} else {
|
||
tracing::info!("📸 using encoder element: {enc}");
|
||
}
|
||
#[cfg(not(coverage))]
|
||
let have_nvvidconv = gst::ElementFactory::find("nvvidconv").is_some();
|
||
let (src_caps, preenc) = match enc {
|
||
// ───────────────────────────────────────────────────────────────────
|
||
// Jetson (has nvvidconv) Desktop (falls back to videoconvert)
|
||
// ───────────────────────────────────────────────────────────────────
|
||
#[cfg(not(coverage))]
|
||
"nvh264enc" if have_nvvidconv =>
|
||
(format!(
|
||
"video/x-raw(memory:NVMM),format=NV12,width={width},height={height},framerate={fps}/1"
|
||
), "nvvidconv !"),
|
||
#[cfg(not(coverage))]
|
||
"nvh264enc" /* else */ =>
|
||
(format!(
|
||
"video/x-raw,format=NV12,width={width},height={height},framerate={fps}/1"
|
||
), "videoconvert !"),
|
||
#[cfg(not(coverage))]
|
||
"vaapih264enc" =>
|
||
(format!(
|
||
"video/x-raw,format=NV12,width={width},height={height},framerate={fps}/1"
|
||
), "videoconvert !"),
|
||
_ =>
|
||
(format!(
|
||
"video/x-raw,width={width},height={height},framerate={fps}/1"
|
||
), "videoconvert !"),
|
||
};
|
||
|
||
// let desc = format!(
|
||
// "v4l2src device={dev} do-timestamp=true ! {raw_caps},width=1280,height=720 ! \
|
||
// videoconvert ! {enc} key-int-max=30 ! \
|
||
// h264parse config-interval=-1 ! \
|
||
// appsink name=asink emit-signals=true max-buffers=60 drop=true"
|
||
// );
|
||
// tracing::debug!(%desc, "📸 pipeline-desc");
|
||
// Build a pipeline that works for any of the three encoders.
|
||
// * nvh264enc needs NVMM memory caps;
|
||
// * vaapih264enc wants system-memory caps;
|
||
// * x264enc needs the usual raw caps.
|
||
let preview_tap_path = camera_preview_tap_path();
|
||
let preview_tap_branch = camera_preview_tap_branch(width, height, fps);
|
||
let raw_source_chain =
|
||
camera_raw_source_chain(&src_desc, &src_caps, width, height, fps, source_profile);
|
||
let desc = if preview_tap_path.is_some() {
|
||
if output_mjpeg {
|
||
if use_mjpg_source {
|
||
format!(
|
||
"{src_desc} ! \
|
||
image/jpeg,width={width},height={height},framerate={fps}/1 ! \
|
||
tee name=t \
|
||
t. ! queue max-size-buffers=30 leaky=downstream ! \
|
||
appsink name=asink emit-signals=true max-buffers=60 drop=true \
|
||
t. ! queue max-size-buffers=2 leaky=downstream ! jpegdec ! \
|
||
{preview_tap_branch}"
|
||
)
|
||
} else {
|
||
format!(
|
||
"{raw_source_chain} ! \
|
||
tee name=t \
|
||
t. ! queue max-size-buffers=30 leaky=downstream ! \
|
||
videoconvert ! jpegenc quality={jpeg_quality} ! \
|
||
appsink name=asink emit-signals=true max-buffers=60 drop=true \
|
||
t. ! queue max-size-buffers=2 leaky=downstream ! \
|
||
{preview_tap_branch}"
|
||
)
|
||
}
|
||
} else if use_mjpg_source {
|
||
format!(
|
||
"{src_desc} ! \
|
||
image/jpeg,width={width},height={height} ! \
|
||
jpegdec ! videorate ! video/x-raw,framerate={fps}/1 ! \
|
||
tee name=t \
|
||
t. ! queue max-size-buffers=30 leaky=downstream ! \
|
||
videoconvert ! {enc_opts} ! \
|
||
h264parse config-interval=-1 ! video/x-h264,stream-format=byte-stream,alignment=au ! \
|
||
appsink name=asink emit-signals=true max-buffers=60 drop=true \
|
||
t. ! queue max-size-buffers=2 leaky=downstream ! \
|
||
{preview_tap_branch}"
|
||
)
|
||
} else {
|
||
format!(
|
||
"{raw_source_chain} ! \
|
||
tee name=t \
|
||
t. ! queue max-size-buffers=30 leaky=downstream ! \
|
||
{preenc} {enc_opts} ! \
|
||
h264parse config-interval=-1 ! video/x-h264,stream-format=byte-stream,alignment=au ! \
|
||
appsink name=asink emit-signals=true max-buffers=60 drop=true \
|
||
t. ! queue max-size-buffers=2 leaky=downstream ! \
|
||
{preview_tap_branch}"
|
||
)
|
||
}
|
||
} else if output_mjpeg {
|
||
if use_mjpg_source {
|
||
format!(
|
||
"{src_desc} ! \
|
||
image/jpeg,width={width},height={height},framerate={fps}/1 ! \
|
||
queue max-size-buffers=30 leaky=downstream ! \
|
||
appsink name=asink emit-signals=true max-buffers=60 drop=true"
|
||
)
|
||
} else {
|
||
format!(
|
||
"{raw_source_chain} ! \
|
||
videoconvert ! jpegenc quality={jpeg_quality} ! \
|
||
queue max-size-buffers=30 leaky=downstream ! \
|
||
appsink name=asink emit-signals=true max-buffers=60 drop=true"
|
||
)
|
||
}
|
||
} else if use_mjpg_source {
|
||
format!(
|
||
"{src_desc} ! \
|
||
image/jpeg,width={width},height={height} ! \
|
||
jpegdec ! videorate ! video/x-raw,framerate={fps}/1 ! \
|
||
videoconvert ! {enc_opts} ! \
|
||
h264parse config-interval=-1 ! video/x-h264,stream-format=byte-stream,alignment=au ! \
|
||
queue max-size-buffers=30 leaky=downstream ! \
|
||
appsink name=asink emit-signals=true max-buffers=60 drop=true"
|
||
)
|
||
} else {
|
||
format!(
|
||
"{raw_source_chain} ! \
|
||
{preenc} {enc_opts} ! \
|
||
h264parse config-interval=-1 ! video/x-h264,stream-format=byte-stream,alignment=au ! \
|
||
queue max-size-buffers=30 leaky=downstream ! \
|
||
appsink name=asink emit-signals=true max-buffers=60 drop=true"
|
||
)
|
||
};
|
||
tracing::info!(%enc, width, height, fps, ?desc, "📸 using encoder element");
|
||
|
||
let pipeline: gst::Pipeline = gst::parse::launch(&desc)
|
||
.context("gst parse_launch(cam)")?
|
||
.downcast::<gst::Pipeline>()
|
||
.expect("not a pipeline");
|
||
|
||
tracing::debug!("📸 pipeline built OK – setting PLAYING…");
|
||
let sink: gst_app::AppSink = pipeline
|
||
.by_name("asink")
|
||
.expect("appsink element not found")
|
||
.downcast::<gst_app::AppSink>()
|
||
.expect("appsink down‑cast");
|
||
|
||
spawn_camera_bus_logger(&pipeline, dev_label.clone());
|
||
if let Err(err) = pipeline.set_state(gst::State::Playing) {
|
||
let _ = pipeline.set_state(gst::State::Null);
|
||
return Err(err.into());
|
||
}
|
||
tracing::info!("📸 webcam pipeline ▶️ device={dev_label}");
|
||
|
||
let preview_tap_running = if let Some(path) = preview_tap_path {
|
||
let preview_sink = pipeline
|
||
.by_name("preview_sink")
|
||
.context("missing camera preview tap appsink")?
|
||
.downcast::<gst_app::AppSink>()
|
||
.expect("camera preview tap appsink");
|
||
Some(spawn_camera_preview_tap(preview_sink, path))
|
||
} else {
|
||
None
|
||
};
|
||
|
||
Ok(Self {
|
||
pipeline,
|
||
sink,
|
||
preview_tap_running,
|
||
})
|
||
}
|
||
|
||
pub fn pull(&self) -> Option<VideoPacket> {
|
||
let sample = self.sink.pull_sample().ok()?;
|
||
let buf = sample.buffer()?;
|
||
let map = buf.map_readable().ok()?;
|
||
let pts = buf.pts().unwrap_or(gst::ClockTime::ZERO).nseconds() / 1_000;
|
||
static FIRST_CAMERA_PACKET: AtomicBool = AtomicBool::new(false);
|
||
if !FIRST_CAMERA_PACKET.swap(true, Ordering::Relaxed) {
|
||
tracing::info!(
|
||
bytes = map.as_slice().len(),
|
||
pts_us = pts,
|
||
"📸 upstream webcam frames flowing"
|
||
);
|
||
}
|
||
Some(VideoPacket {
|
||
id: 2,
|
||
pts,
|
||
data: map.as_slice().to_vec(),
|
||
..Default::default()
|
||
})
|
||
}
|
||
|
||
/// Fuzzy‑match devices under `/dev/v4l/by-id`, preferring capture nodes
|
||
#[cfg(not(coverage))]
|
||
fn find_device(substr: &str) -> Option<String> {
|
||
let wanted = substr.to_ascii_lowercase();
|
||
let mut matches: Vec<_> = std::fs::read_dir("/dev/v4l/by-id")
|
||
.ok()?
|
||
.flatten()
|
||
.filter_map(|e| {
|
||
let p = e.path();
|
||
let name = p.file_name()?.to_string_lossy().to_ascii_lowercase();
|
||
if name.contains(&wanted) {
|
||
Some(p)
|
||
} else {
|
||
None
|
||
}
|
||
})
|
||
.collect();
|
||
|
||
// deterministic order
|
||
matches.sort();
|
||
|
||
for p in matches {
|
||
if let Ok(target) = std::fs::read_link(&p) {
|
||
let dev = format!("/dev/{}", target.file_name()?.to_string_lossy());
|
||
if Self::is_capture(&dev) {
|
||
return Some(dev);
|
||
}
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
#[cfg(coverage)]
|
||
fn find_device(substr: &str) -> Option<String> {
|
||
let wanted = substr.to_ascii_lowercase();
|
||
let by_id_dir =
|
||
std::env::var("LESAVKA_CAM_BY_ID_DIR").unwrap_or_else(|_| "/dev/v4l/by-id".to_string());
|
||
let dev_root = std::env::var("LESAVKA_CAM_DEV_ROOT").unwrap_or_else(|_| "/dev".to_string());
|
||
let mut matches: Vec<_> = std::fs::read_dir(by_id_dir)
|
||
.ok()?
|
||
.flatten()
|
||
.filter_map(|e| {
|
||
let p = e.path();
|
||
let name = p.file_name()?.to_string_lossy().to_ascii_lowercase();
|
||
if name.contains(&wanted) {
|
||
Some(p)
|
||
} else {
|
||
None
|
||
}
|
||
})
|
||
.collect();
|
||
matches.sort();
|
||
for p in matches {
|
||
if let Ok(target) = std::fs::read_link(&p) {
|
||
let dev = format!("{}/{}", dev_root, target.file_name()?.to_string_lossy());
|
||
if Self::is_capture(&dev) {
|
||
return Some(dev);
|
||
}
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
#[cfg(not(coverage))]
|
||
fn is_capture(dev: &str) -> bool {
|
||
const V4L2_CAP_VIDEO_CAPTURE: u32 = 0x0000_0001;
|
||
const V4L2_CAP_VIDEO_CAPTURE_MPLANE: u32 = 0x0000_1000;
|
||
|
||
v4l::Device::with_path(dev)
|
||
.ok()
|
||
.and_then(|d| d.query_caps().ok())
|
||
.map(|caps| {
|
||
let bits = caps.capabilities.bits();
|
||
(bits & V4L2_CAP_VIDEO_CAPTURE != 0) || (bits & V4L2_CAP_VIDEO_CAPTURE_MPLANE != 0)
|
||
})
|
||
.unwrap_or(false)
|
||
}
|
||
|
||
#[cfg(coverage)]
|
||
fn is_capture(dev: &str) -> bool {
|
||
dev.starts_with("/dev/video")
|
||
}
|
||
|
||
/// Cheap stub used when the web‑cam is disabled
|
||
pub fn new_stub() -> Self {
|
||
let pipeline = gst::Pipeline::new();
|
||
let sink: gst_app::AppSink = gst::ElementFactory::make("appsink")
|
||
.build()
|
||
.expect("appsink")
|
||
.downcast::<gst_app::AppSink>()
|
||
.unwrap();
|
||
Self {
|
||
pipeline,
|
||
sink,
|
||
preview_tap_running: None,
|
||
}
|
||
}
|
||
|
||
#[allow(dead_code)] // helper kept for future heuristics
|
||
#[cfg(not(coverage))]
|
||
fn pick_encoder() -> (&'static str, &'static str) {
|
||
let encoders = &[
|
||
("nvh264enc", "video/x-raw(memory:NVMM),format=NV12"),
|
||
("vaapih264enc", "video/x-raw,format=NV12"),
|
||
("v4l2h264enc", "video/x-raw"), // RPi, Jetson, etc.
|
||
("x264enc", "video/x-raw"), // software
|
||
];
|
||
for (name, caps) in encoders {
|
||
if gst::ElementFactory::find(name).is_some() {
|
||
return (name, caps);
|
||
}
|
||
}
|
||
// last resort – software
|
||
("x264enc", "video/x-raw")
|
||
}
|
||
|
||
#[cfg(coverage)]
|
||
fn pick_encoder() -> (&'static str, &'static str) {
|
||
("x264enc", "video/x-raw")
|
||
}
|
||
|
||
#[cfg(not(coverage))]
|
||
fn choose_encoder() -> (&'static str, Option<&'static str>) {
|
||
if buildable_encoder("nvh264enc") {
|
||
return (
|
||
"nvh264enc",
|
||
supported_encoder_property(
|
||
"nvh264enc",
|
||
&["iframeinterval", "idrinterval", "gop-size"],
|
||
),
|
||
);
|
||
}
|
||
if buildable_encoder("vaapih264enc") {
|
||
return (
|
||
"vaapih264enc",
|
||
supported_encoder_property("vaapih264enc", &["keyframe-period"]),
|
||
);
|
||
}
|
||
if buildable_encoder("v4l2h264enc") {
|
||
return (
|
||
"v4l2h264enc",
|
||
supported_encoder_property("v4l2h264enc", &["idrcount"]),
|
||
);
|
||
}
|
||
("x264enc", Some("key-int-max"))
|
||
}
|
||
|
||
#[cfg(coverage)]
|
||
fn choose_encoder() -> (&'static str, Option<&'static str>) {
|
||
match std::env::var("LESAVKA_CAM_TEST_ENCODER")
|
||
.ok()
|
||
.as_deref()
|
||
.map(str::trim)
|
||
{
|
||
Some("nvh264enc") => ("nvh264enc", None),
|
||
Some("vaapih264enc") => ("vaapih264enc", Some("keyframe-period")),
|
||
Some("v4l2h264enc") => ("v4l2h264enc", Some("idrcount")),
|
||
_ => ("x264enc", Some("key-int-max")),
|
||
}
|
||
}
|
||
|
||
fn encoder_options(
|
||
enc: &'static str,
|
||
kf_prop: Option<&'static str>,
|
||
keyframe_interval: u32,
|
||
) -> String {
|
||
if enc == "x264enc" {
|
||
let bitrate_kbit = env_u32("LESAVKA_CAM_H264_KBIT", 4500);
|
||
let keyframe_opt = kf_prop
|
||
.map(|property| format!(" {property}={keyframe_interval}"))
|
||
.unwrap_or_default();
|
||
format!(
|
||
"{enc} tune=zerolatency speed-preset=faster bitrate={bitrate_kbit}{keyframe_opt}"
|
||
)
|
||
} else if let Some(property) = kf_prop {
|
||
format!("{enc} {property}={keyframe_interval}")
|
||
} else {
|
||
enc.to_string()
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Choose the pre-encoder webcam format path.
|
||
///
|
||
/// V4L2 webcams often expose 720p/30 as MJPEG only, so the default accepts
|
||
/// either raw frames or MJPEG unless the operator explicitly pins a format.
|
||
fn camera_source_profile(allow_v4l2_auto_decode: bool) -> CameraSourceProfile {
|
||
if !allow_v4l2_auto_decode {
|
||
return CameraSourceProfile::Raw;
|
||
}
|
||
if std::env::var("LESAVKA_CAM_MJPG").is_ok() {
|
||
return CameraSourceProfile::Mjpeg;
|
||
}
|
||
match std::env::var("LESAVKA_CAM_FORMAT")
|
||
.ok()
|
||
.as_deref()
|
||
.map(str::trim)
|
||
.map(str::to_ascii_lowercase)
|
||
.as_deref()
|
||
{
|
||
Some("mjpg" | "mjpeg" | "jpeg") => CameraSourceProfile::Mjpeg,
|
||
Some("raw" | "yuyv" | "yuy2") => CameraSourceProfile::Raw,
|
||
_ => CameraSourceProfile::AutoDecode,
|
||
}
|
||
}
|
||
|
||
/// Build the source-to-raw-video chain consumed by the encoder and preview tap.
|
||
fn camera_raw_source_chain(
|
||
src_desc: &str,
|
||
src_caps: &str,
|
||
width: u32,
|
||
height: u32,
|
||
fps: u32,
|
||
profile: CameraSourceProfile,
|
||
) -> String {
|
||
match profile {
|
||
CameraSourceProfile::Raw => format!("{src_desc} ! {src_caps}"),
|
||
CameraSourceProfile::Mjpeg => format!(
|
||
"{src_desc} ! \
|
||
image/jpeg,width={width},height={height},framerate={fps}/1 ! \
|
||
jpegdec ! videoconvert ! videoscale ! videorate ! \
|
||
video/x-raw,width={width},height={height},framerate={fps}/1"
|
||
),
|
||
CameraSourceProfile::AutoDecode => format!(
|
||
"{src_desc} ! \
|
||
capsfilter caps=\"{}\" ! \
|
||
decodebin ! videoconvert ! videoscale ! videorate ! \
|
||
video/x-raw,width={width},height={height},framerate={fps}/1,pixel-aspect-ratio=1/1",
|
||
camera_auto_decode_caps(width, height, fps)
|
||
),
|
||
}
|
||
}
|
||
|
||
/// Caps string that lets decodebin negotiate either raw webcam frames or MJPEG.
|
||
fn camera_auto_decode_caps(width: u32, height: u32, fps: u32) -> String {
|
||
format!(
|
||
"video/x-raw,width=(int){width},height=(int){height},framerate=(fraction){fps}/1;image/jpeg,width=(int){width},height=(int){height},framerate=(fraction){fps}/1"
|
||
)
|
||
}
|
||
|
||
fn camera_preview_tap_path() -> Option<PathBuf> {
|
||
std::env::var(CAMERA_PREVIEW_TAP_ENV)
|
||
.ok()
|
||
.map(|value| value.trim().to_string())
|
||
.filter(|value| !value.is_empty())
|
||
.map(PathBuf::from)
|
||
}
|
||
|
||
fn camera_preview_tap_branch(width: u32, height: u32, fps: u32) -> String {
|
||
let preview_width = width.clamp(1, i32::MAX as u32);
|
||
let preview_height = height.clamp(1, i32::MAX as u32);
|
||
let preview_fps = fps.clamp(1, 60);
|
||
format!(
|
||
"videoconvert ! videoscale ! videorate ! \
|
||
video/x-raw,format=RGBA,width={preview_width},height={preview_height},framerate={preview_fps}/1,pixel-aspect-ratio=1/1 ! \
|
||
appsink name=preview_sink emit-signals=false sync=false max-buffers=1 drop=true"
|
||
)
|
||
}
|
||
|
||
/// Publish actual-size local preview frames so the launcher mirrors uplink quality.
|
||
fn spawn_camera_preview_tap(sink: gst_app::AppSink, path: PathBuf) -> Arc<AtomicBool> {
|
||
let running = Arc::new(AtomicBool::new(true));
|
||
let thread_running = Arc::clone(&running);
|
||
thread::spawn(move || {
|
||
let mut wrote_first = false;
|
||
let mut empty_polls = 0_u64;
|
||
while thread_running.load(Ordering::Acquire) {
|
||
if let Some(sample) = sink.try_pull_sample(gst::ClockTime::from_mseconds(250)) {
|
||
empty_polls = 0;
|
||
match write_camera_preview_tap(&path, &sample) {
|
||
Ok(info) => {
|
||
if !wrote_first {
|
||
wrote_first = true;
|
||
tracing::info!(
|
||
path = %path.display(),
|
||
width = info.width,
|
||
height = info.height,
|
||
stride = info.stride,
|
||
"📸 local uplink preview tap publishing frames"
|
||
);
|
||
}
|
||
}
|
||
Err(err) => {
|
||
tracing::debug!("📸 local uplink preview tap write failed: {err:#}");
|
||
thread::sleep(Duration::from_millis(100));
|
||
}
|
||
}
|
||
} else if !wrote_first {
|
||
empty_polls += 1;
|
||
if empty_polls == 20 || empty_polls.is_multiple_of(120) {
|
||
tracing::warn!(
|
||
path = %path.display(),
|
||
"📸 local uplink preview tap is still waiting for webcam frames"
|
||
);
|
||
}
|
||
}
|
||
}
|
||
});
|
||
running
|
||
}
|
||
|
||
struct CameraPreviewTapInfo {
|
||
width: i32,
|
||
height: i32,
|
||
stride: usize,
|
||
}
|
||
|
||
/// Atomically write one RGBA preview sample for the launcher status pane.
|
||
fn write_camera_preview_tap(
|
||
path: &Path,
|
||
sample: &gst::Sample,
|
||
) -> anyhow::Result<CameraPreviewTapInfo> {
|
||
let caps = sample.caps().context("preview tap sample missing caps")?;
|
||
let structure = caps
|
||
.structure(0)
|
||
.context("preview tap caps missing structure")?;
|
||
let width = structure
|
||
.get::<i32>("width")
|
||
.context("preview tap caps missing width")?;
|
||
let height = structure
|
||
.get::<i32>("height")
|
||
.context("preview tap caps missing height")?;
|
||
let buffer = sample
|
||
.buffer()
|
||
.context("preview tap sample missing buffer")?;
|
||
let map = buffer
|
||
.map_readable()
|
||
.context("preview tap buffer unreadable")?;
|
||
let row_count = usize::try_from(height)
|
||
.ok()
|
||
.filter(|height| *height > 0)
|
||
.unwrap_or(1);
|
||
let stride = map.as_slice().len() / row_count;
|
||
let tmp_path = path.with_extension("tmp");
|
||
let mut file = std::fs::File::create(&tmp_path)
|
||
.with_context(|| format!("creating {}", tmp_path.display()))?;
|
||
writeln!(file, "LESAVKA_RGBA {width} {height} {stride}")?;
|
||
file.write_all(map.as_slice())?;
|
||
file.sync_all().ok();
|
||
std::fs::rename(&tmp_path, path).with_context(|| format!("publishing {}", path.display()))?;
|
||
Ok(CameraPreviewTapInfo {
|
||
width,
|
||
height,
|
||
stride,
|
||
})
|
||
}
|
||
|
||
/// Forward camera bus warnings/errors into the relay log with the device label.
|
||
fn spawn_camera_bus_logger(pipeline: &gst::Pipeline, device: String) {
|
||
let Some(bus) = pipeline.bus() else {
|
||
return;
|
||
};
|
||
std::thread::spawn(move || {
|
||
use gst::MessageView::{Error, StateChanged, Warning};
|
||
for msg in bus.iter_timed(gst::ClockTime::NONE) {
|
||
match msg.view() {
|
||
StateChanged(s)
|
||
if s.current() == gst::State::Playing
|
||
&& msg.src().is_some_and(|source| {
|
||
source.type_() == gst::Pipeline::static_type()
|
||
}) =>
|
||
{
|
||
tracing::info!(%device, "📸 camera pipeline ▶️");
|
||
}
|
||
Error(e) => tracing::error!(
|
||
%device,
|
||
"📸💥 camera: {} ({})",
|
||
e.error(),
|
||
e.debug().unwrap_or_default()
|
||
),
|
||
Warning(w) => tracing::warn!(
|
||
%device,
|
||
"📸⚠️ camera: {} ({})",
|
||
w.error(),
|
||
w.debug().unwrap_or_default()
|
||
),
|
||
_ => {}
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
#[cfg(not(coverage))]
|
||
fn buildable_encoder(encoder: &'static str) -> bool {
|
||
gst::ElementFactory::find(encoder).is_some()
|
||
&& gst::ElementFactory::make(encoder).build().is_ok()
|
||
}
|
||
|
||
#[cfg(not(coverage))]
|
||
fn supported_encoder_property(
|
||
encoder: &'static str,
|
||
properties: &[&'static str],
|
||
) -> Option<&'static str> {
|
||
let element = gst::ElementFactory::make(encoder).build().ok()?;
|
||
properties
|
||
.iter()
|
||
.copied()
|
||
.find(|property| element.find_property(property).is_some())
|
||
}
|
||
|
||
impl Drop for CameraCapture {
|
||
fn drop(&mut self) {
|
||
if let Some(running) = &self.preview_tap_running {
|
||
running.store(false, Ordering::Release);
|
||
}
|
||
let _ = self.pipeline.set_state(gst::State::Null);
|
||
}
|
||
}
|