pocketstation 1.0.0

Source-aware desktop audio Session SDK
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! Control-plane source discovery queries used by the first-party CLI.

use std::collections::HashSet;

use super::{CaptureSource, SourceKind, SourceState, StableSourceId};
use crate::frame::Platform;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SourceQuery {
    Any,
    App(String),
    ByKind(SourceKind),
    ByStableKey(String),
    Playing,
}

impl SourceQuery {
    pub fn matches(&self, source: &CaptureSource) -> bool {
        match self {
            Self::Any => true,
            Self::App(name) => {
                let needle = name.to_lowercase();
                source
                    .app_id
                    .as_deref()
                    .is_some_and(|application| application.to_lowercase().contains(&needle))
                    || source.name.to_lowercase().contains(&needle)
            }
            Self::ByKind(kind) => source.stable_id.kind == *kind,
            Self::ByStableKey(key) => &source.stable_id.stable_key == key,
            Self::Playing => source.state == SourceState::Playing,
        }
    }
}

pub fn resolve_query(query: &SourceQuery, sources: &[CaptureSource]) -> Vec<CaptureSource> {
    sources
        .iter()
        .filter(|source| query.matches(source))
        .cloned()
        .collect()
}

pub trait SourceProvider {
    fn discover(&self, query: &SourceQuery) -> Vec<CaptureSource>;
}

pub struct LocalSourceProvider;

impl SourceProvider for LocalSourceProvider {
    fn discover(&self, query: &SourceQuery) -> Vec<CaptureSource> {
        resolve_query(query, &discover_sources())
    }
}

/// Reports whether this host exposes the native application-capture facility.
///
/// This is a control-plane capability query. It does not open a device, prompt
/// for permission, or create a capture/runtime owner.
pub fn application_capture_available() -> bool {
    #[cfg(target_os = "macos")]
    {
        super::platform::macos::tap_available()
    }
    #[cfg(any(target_os = "windows", target_os = "linux"))]
    {
        true
    }
    #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]
    {
        false
    }
}

pub fn discover_sources() -> Vec<CaptureSource> {
    #[cfg(target_os = "macos")]
    let platform = Platform::Macos;
    #[cfg(target_os = "windows")]
    let platform = Platform::Windows;
    #[cfg(target_os = "linux")]
    let platform = Platform::Linux;
    #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]
    let platform = Platform::Unknown;

    let mut sources = vec![CaptureSource {
        stable_id: StableSourceId::new(platform, SourceKind::SystemMix, "system:mix"),
        name: "System Mix".to_owned(),
        process_id: None,
        app_id: None,
        device_uid: None,
        state: SourceState::Available,
        sample_rate_hz: 48_000,
        channels: 2,
    }];

    #[cfg(target_os = "macos")]
    {
        sources.extend(super::platform::macos::discover_input_sources_native());
        sources.extend(super::platform::macos::discover_sources_native());
    }

    #[cfg(target_os = "windows")]
    sources.extend(super::platform::windows::discover_sources_windows());

    #[cfg(target_os = "linux")]
    sources.extend(super::platform::linux::discover_sources_linux());

    let mut seen = HashSet::new();
    sources
        .into_iter()
        .filter(|source| {
            seen.insert((
                source.stable_id.platform,
                source.stable_id.kind,
                source.stable_id.stable_key.clone(),
                source.process_id,
            ))
        })
        .collect()
}