Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

6.4 KB
Raw Blame
use std::{
    collections::HashMap,
    sync::{Arc, RwLock},
    time::Instant,
};
use tokio::sync::OnceCell;

#[derive(Clone)]
pub struct PendingScreenshot {
    pub data: Vec<u8>,
    pub width: u32,
    pub height: u32,
    pub channels: u32,
    pub created_at: Instant,
}

pub struct PendingScreenshots(pub Arc<RwLock<HashMap<String, PendingScreenshot>>>);

impl Default for PendingScreenshots {
    fn default() -> Self {
        Self(Arc::new(RwLock::new(HashMap::new())))
    }
}

impl PendingScreenshots {
    pub fn insert(&self, key: String, screenshot: PendingScreenshot) {
        let mut guard = self.0.write().unwrap();
        guard.retain(|_, v| v.created_at.elapsed() < std::time::Duration::from_secs(10));
        guard.insert(key, screenshot);
    }

    pub fn remove(&self, key: &str) -> Option<PendingScreenshot> {
        self.0.write().unwrap().remove(key)
    }

    pub fn get(&self, key: &str) -> Option<PendingScreenshot> {
        self.0.read().unwrap().get(key).cloned()
    }
}

pub struct SharedGpuContext {
    health: crate::gpu_device_health::GpuDeviceHealth,
    pub device: Arc<wgpu::Device>,
    pub queue: Arc<wgpu::Queue>,
    pub adapter: Arc<wgpu::Adapter>,
    pub instance: Arc<wgpu::Instance>,
    pub is_software_adapter: bool,
    pub background_cache: Arc<cap_rendering::BackgroundTextureCache>,
}

static GPU: OnceCell<Option<SharedGpuContext>> = OnceCell::const_new();

/// Marks the crash sentinel while GPU adapter/device initialisation is in flight, so
/// a process death inside that window is attributable to graphics bring-up. Dropping
/// the guard (including during unwind from a caught panic) disarms the marker — a
/// survivable failure is not a GPU crash.
struct GpuInitPhaseGuard;

impl GpuInitPhaseGuard {
    fn arm() -> Self {
        crate::crash_sentinel::enter_gpu_init_phase();
        Self
    }
}

impl Drop for GpuInitPhaseGuard {
    fn drop(&mut self) {
        crate::crash_sentinel::exit_gpu_init_phase();
    }
}

async fn init_gpu_inner() -> Option<SharedGpuContext> {
    let _gpu_init_phase = GpuInitPhaseGuard::arm();

    let instance = cap_rendering::create_wgpu_instance().await;

    let force_software_adapter = cap_rendering::force_software_wgpu_adapter();
    if force_software_adapter {
        tracing::warn!("Forcing software WGPU adapter for shared context");
    }

    let hardware_adapter = if force_software_adapter {
        None
    } else {
        instance
            .request_adapter(&wgpu::RequestAdapterOptions {
                power_preference: wgpu::PowerPreference::HighPerformance,
                force_fallback_adapter: false,
                compatible_surface: None,
            })
            .await
            .ok()
    };

    let (adapter, is_software_adapter) = if let Some(adapter) = hardware_adapter {
        let adapter_info = adapter.get_info();
        let is_software_adapter = cap_rendering::is_software_wgpu_adapter(&adapter_info);

        if is_software_adapter {
            tracing::warn!(
                adapter_name = adapter_info.name,
                adapter_backend = ?adapter_info.backend,
                adapter_device_type = ?adapter_info.device_type,
                "Selected shared-context adapter behaves like a software renderer"
            );
        } else {
            tracing::info!(
                adapter_name = adapter_info.name,
                adapter_backend = ?adapter_info.backend,
                adapter_device_type = ?adapter_info.device_type,
                "Using hardware GPU adapter for shared context"
            );
        }

        (adapter, is_software_adapter)
    } else {
        tracing::warn!(
            "No hardware GPU adapter found, attempting software fallback for shared context"
        );
        let software_adapter = instance
            .request_adapter(&wgpu::RequestAdapterOptions {
                power_preference: wgpu::PowerPreference::LowPower,
                force_fallback_adapter: true,
                compatible_surface: None,
            })
            .await
            .ok()?;

        let adapter_info = software_adapter.get_info();

        tracing::info!(
            adapter_name = adapter_info.name,
            adapter_backend = ?adapter_info.backend,
            adapter_device_type = ?adapter_info.device_type,
            "Using software adapter for shared context (CPU rendering - performance may be reduced)"
        );
        (software_adapter, true)
    };

    let (device, queue) = adapter
        .request_device(&wgpu::DeviceDescriptor {
            label: Some("cap-shared-gpu-device"),
            required_features: wgpu::Features::empty(),
            ..Default::default()
        })
        .await
        .ok()?;

    let health = crate::gpu_device_health::GpuDeviceHealth::track(&device, |reason, message| {
        tracing::error!(?reason, %message, "Shared GPU device lost");
        if reason == wgpu::DeviceLostReason::Unknown {
            sentry::capture_message("Shared GPU device lost", sentry::Level::Error);
        }
    });

    Some(SharedGpuContext {
        health,
        device: Arc::new(device),
        queue: Arc::new(queue),
        adapter: Arc::new(adapter),
        instance: Arc::new(instance),
        is_software_adapter,
        background_cache: Arc::new(cap_rendering::BackgroundTextureCache::default()),
    })
}

pub async fn get_shared_gpu() -> Option<&'static SharedGpuContext> {
    GPU.get_or_init(|| async {
        let result = tokio::spawn(init_gpu_inner()).await;

        match result {
            Ok(ctx) => ctx,
            Err(e) => {
                if e.is_panic() {
                    tracing::error!(
                        "GPU initialization panicked (wgpu internal error). \
                         The app will continue without GPU acceleration."
                    );
                } else {
                    tracing::error!(
                        error = %e,
                        "GPU initialization task failed"
                    );
                }
                None
            }
        }
    })
    .await
    .as_ref()
}

pub fn prewarm_gpu() {
    tokio::spawn(async {
        get_shared_gpu().await;
    });
}

// Every Tauri video editor uses this OnceCell's device when initialization succeeds.
// Its resources cannot recover by reopening the editor or replacing only the device.
pub fn ensure_shared_device_available() -> Result<(), String> {
    if let Some(Some(gpu)) = GPU.get() {
        gpu.health.ensure_available().map_err(str::to_string)?;
    }
    Ok(())
}