Struct Microphone

#[repr(C)]
pub struct Microphone { /* private fields */ }

This class provides access to the hardware’s microphone, and stores it in a Sound stream. Start and Stop recording, and check the Sound property for the results! Remember to ensure your application has microphone permissions enabled! https://stereokit.net/Pages/StereoKit/Microphone.html

see also: Sound /// ### Examples

use stereokit_rust::{maths::{Vec3, Matrix}, mesh::Mesh, material::Material,
                     sound::Sound, system::Microphone, util::named_colors};

let sphere = Mesh::generate_cube(Vec3::ONE * 0.5, None);
let material = Material::pbr().tex_file_copy("textures/micro.jpeg", true, None)
                   .expect("sound.jpeg should be there");
let mut position = Vec3::new( 0.0, 0.0, 0.5);
let transform = Matrix::t(position);

let micros = Microphone::get_devices();

if micros.len() > 0 {
    let first_in_list = micros[0].clone();
    if Microphone::start(Some(first_in_list)) {
        assert!(Microphone::is_recording());
    } else {
        assert!(!Microphone::is_recording());
    }
}

filename_scr = "screenshots/microphone.jpeg";
test_screenshot!( // !!!! Get a proper main loop !!!!
    sphere.draw(token, &material, transform, Some(named_colors::LIGHT_BLUE.into()), None  );
    if iter == 1990 && Microphone::is_recording() {
        let micro_sound = Microphone::sound().expect("Microphone should be recording");
        let mut read_samples: Vec<f32> = vec![0.0; 48000];
        let recorded_data = micro_sound.read_samples(read_samples.as_mut_slice(), None);
        Microphone::stop();
        //assert_ne!(recorded_data, 0);
    }
);

Implementations

impl Microphone

pub fn sound() -> Result<Sound, StereoKitError>

This is the sound stream of the Microphone when it is recording. This Asset is created the first time it is accessed via this property, or during Start, and will persist. It is re-used for the Microphone stream if you start/stop/switch devices. https://stereokit.net/Pages/StereoKit/Microphone/Sound.html

see also mic_get_stream

pub fn is_recording() -> bool

Is the microphone currently recording? https://stereokit.net/Pages/StereoKit/Microphone/IsRecording.html

see also mic_is_recording

pub fn get_devices() -> Vec<String>

Constructs a list of valid Microphone devices attached to the system. These names can be passed into Start to select a specific device to record from. It’s recommended to cache this list if you’re using it frequently, as this list is constructed each time you call it.

It’s good to note that a user might occasionally plug or unplug microphone devices from their system, so this list may occasionally change. https://stereokit.net/Pages/StereoKit/Microphone/GetDevices.html

see also mic_device_count mic_device_name

pub fn start(device_name: Option<String>) -> bool

This begins recording audio from the Microphone! Audio is stored in Microphone.Sound as a stream of audio. If the Microphone is already recording with a different device, it will stop the previous recording and start again with the new device.

If null is provided as the device, then they system’s default input device will be used. Some systems may not provide access to devices other than the system’s default. https://stereokit.net/Pages/StereoKit/Microphone/Start.html

• device_name - The name of the microphone device to use, as seen in the GetDevices list. None will use the system’s default device preference.

see also mic_start Microphone::get_devices Microphone::stop

pub fn stop()

Stops recording audio from the microphone. https://stereokit.net/Pages/StereoKit/Microphone/Stop.html

see also mic_stop

Trait Implementations

impl Debug for Microphone

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Microphone

fn eq(&self, other: &Microphone) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Microphone