whisper-apr 0.3.3

WASM-first automatic speech recognition engine implementing OpenAI Whisper
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! WASM GPU capabilities bindings

use wasm_bindgen::prelude::*;

use crate::gpu::GpuCapabilities;

use super::backend::GpuBackendWasm;
use super::limits::GpuLimitsWasm;

/// WASM-friendly GPU capabilities
#[wasm_bindgen]
#[derive(Debug, Clone)]
pub struct GpuCapabilitiesWasm {
    pub(super) backend: GpuBackendWasm,
    pub(super) device_name: String,
    pub(super) vendor_name: String,
    pub(super) driver_info: String,
    pub(super) supports_f16: bool,
    pub(super) supports_timestamp_query: bool,
    pub(super) limits: GpuLimitsWasm,
}

#[wasm_bindgen]
impl GpuCapabilitiesWasm {
    /// Get the GPU backend type
    #[wasm_bindgen(getter)]
    pub fn backend(&self) -> GpuBackendWasm {
        self.backend
    }

    /// Get the device name
    #[wasm_bindgen(getter, js_name = deviceName)]
    pub fn device_name(&self) -> String {
        self.device_name.clone()
    }

    /// Get the vendor name
    #[wasm_bindgen(getter, js_name = vendorName)]
    pub fn vendor_name(&self) -> String {
        self.vendor_name.clone()
    }

    /// Get the driver info
    #[wasm_bindgen(getter, js_name = driverInfo)]
    pub fn driver_info(&self) -> String {
        self.driver_info.clone()
    }

    /// Check if F16 (half precision) is supported
    #[wasm_bindgen(getter, js_name = supportsF16)]
    pub fn supports_f16(&self) -> bool {
        self.supports_f16
    }

    /// Check if timestamp queries are supported
    #[wasm_bindgen(getter, js_name = supportsTimestampQuery)]
    pub fn supports_timestamp_query(&self) -> bool {
        self.supports_timestamp_query
    }

    /// Get GPU limits
    #[wasm_bindgen(getter)]
    pub fn limits(&self) -> GpuLimitsWasm {
        self.limits.clone()
    }

    /// Get backend name as string
    #[wasm_bindgen(js_name = backendName)]
    pub fn backend_name(&self) -> String {
        match self.backend {
            GpuBackendWasm::Vulkan => "Vulkan".to_string(),
            GpuBackendWasm::Metal => "Metal".to_string(),
            GpuBackendWasm::Dx12 => "DirectX 12".to_string(),
            GpuBackendWasm::BrowserWebGpu => "WebGPU".to_string(),
            GpuBackendWasm::Gl => "OpenGL".to_string(),
            GpuBackendWasm::None => "None".to_string(),
        }
    }

    /// Get a summary of capabilities
    #[wasm_bindgen]
    pub fn summary(&self) -> String {
        format!(
            "GPU: {} ({}) | Backend: {} | F16: {} | Max Buffer: {:.0}MB",
            self.device_name,
            self.vendor_name,
            self.backend_name(),
            if self.supports_f16 { "Yes" } else { "No" },
            self.limits.max_buffer_size_mb()
        )
    }
}

impl From<GpuCapabilities> for GpuCapabilitiesWasm {
    fn from(caps: GpuCapabilities) -> Self {
        Self {
            backend: caps.backend.into(),
            device_name: caps.name,
            vendor_name: caps.vendor,
            driver_info: String::new(), // Not available in native GpuCapabilities
            supports_f16: caps.supports_f16,
            supports_timestamp_query: caps.supports_timestamp_query,
            limits: caps.limits.into(),
        }
    }
}