Method new

perro_source/audio_stack/perro_pawdio/src/controller.rs:43–213

(static_audio_lookup: Option<fn(u64) -> &'static [u8]>)

    tx: Sender<AudioCommand>,
    next_playback_id: Arc<AtomicU64>,
    source_pool: Mutex<HashMap<u64, Arc<str>>>,
    loaded: Arc<Mutex<AudioLoadedState>>,
}

#[derive(Default)]
struct AudioLoadedState {
    sources: HashSet<Arc<str>>,
    soundfonts: HashSet<perro_ids::SoundFontID>,
}

#[derive(Clone)]
pub struct AudioSourceHandle {
    source: Arc<str>,
}

impl AudioSourceHandle {
    #[must_use]
    pub fn as_str(&self) -> &str {
        &self.source
    }
}

fn run_audio_worker<F>(
    static_audio_lookup: Option<fn(u64) -> &'static [u8]>,
    player_factory: F,
    commands: &Receiver<AudioCommand>,
    startup: &Sender<Result<(), String>>,
    loaded: &Mutex<AudioLoadedState>,
) where
    F: FnOnce(Option<fn(u64) -> &'static [u8]>) -> Result<BarkPlayer, String>,
{
    let player = match player_factory(static_audio_lookup) {
        Ok(player) => player,
        Err(err) => {
            let _ = startup.send(Err(err));
            return;
        }
    };
    if startup.send(Ok(())).is_err() {
        return;
    }

    while let Ok(command) = commands.recv() {
        process_audio_command(&player, command, loaded);
    }
}

fn set_source_loaded(loaded: &Mutex<AudioLoadedState>, source: &Arc<str>, value: bool) {
    let Ok(mut loaded) = loaded.lock() else {
        return;
    };
    if value {
        loaded.sources.insert(Arc::clone(source));
    } else {
        loaded.sources.remove(source);
    }
}