Zackriya-Solutions/meetily · error

No compatible input configuration found for device: {}

Error message

No compatible input configuration found for device: {}

What it means

In get_windows_device's input branch (windows.rs:165): a WASAPI device whose name matched was found, but device.supported_input_configs() either returned Err (warn 'Could not enumerate' logged just above) or an empty list, so there is no configuration to build a stream from. Because the return happens inside the matched-device branch, the default-input-device fallback below never runs for this case - a matched-but-unusable device is a hard error.

Source

Thrown at frontend/src-tauri/src/audio/devices/platform/windows.rs:165

                                        // Then try any F32 format
                                        for config in &configs {
                                            if config.sample_format() == cpal::SampleFormat::F32 {
                                                let config = config.with_max_sample_rate();
                                                // info!("Using F32 input config: {:?}", config);
                                                return Ok((device, config));
                                            }
                                        }

                                        // Finally, use the first available config
                                        let config = configs[0].with_max_sample_rate();
                                        info!("Using fallback input config: {:?}", config);
                                        return Ok((device, config));
                                    }
                                } else {
                                    warn!("Could not enumerate supported configurations for device: {}", name);
                                }

                                return Err(anyhow!("No compatible input configuration found for device: {}", name));
                            }
                        }
                    }
                }
            }

            // If we didn't find a matching device, try the default input device as fallback
            info!("No matching input device found, trying default input device");
            if let Some(default_device) = wasapi_host.default_input_device() {
                if let Ok(_name) = default_device.name() {
                    // info!("Using default input device: {}", _name);
                    if let Ok(config) = default_device.default_input_config() {
                        return Ok((default_device, config));
                    } else if let Ok(supported_configs) = default_device.supported_input_configs() {
                        if let Some(config) = supported_configs.into_iter().next() {
                            return Ok((default_device, config.with_max_sample_rate()));
                        }
                    }

View on GitHub (pinned to 0281737d87)

Solutions

1. Read the paired warn log to confirm which case it is (enumeration error vs empty list).
2. Free the device: close apps that may hold it, disable exclusive mode (Sound > device Properties > Advanced), re-enable the device in Device Manager.
3. For Bluetooth, switch the headset to communications/HFP mode (join a call or set it as default communications device) so input formats appear, or use a wired mic.
4. Power-cycle the Bluetooth/USB device to force driver re-initialization, then refresh the in-app device list and re-select.
5. If patching: remove the early return at windows.rs:165 so the shared default_input_device fallback handles the matched-but-no-configs case.

Example fix

// before: matched device with no enumerable configs aborts before the fallback
return Err(anyhow!("No compatible input configuration found for device: {}", name));

// after: fall through to the shared default-device fallback instead of failing here
warn!("No compatible input config for '{}', falling back to default input", name);
// (delete the early return; control flows to wasapi_host.default_input_device() below)

// Probe format availability cheaply before committing to the device
fn has_any_input_format(dev: &cpal::Device) -> bool {
    dev.supported_input_configs().map(|mut it| it.next().is_some()).unwrap_or(false)
}

// Matched device unusable -> retry once with the default input device
let found = match get_windows_device(&dev) {
    Ok(ok) => ok,
    Err(e) if e.to_string().contains("No compatible input configuration") => {
        info!("Retrying with default input device");
        default_input_device_and_config()?
    }
    Err(e) => return Err(e),
};

When it happens

Trigger: A Windows input device matched by name while it is disabled in Device Manager or in exclusive use by another app (exclusive mode reserves formats); a device whose formats failed enumeration (driver problem, misconfigured virtual cable); supported_input_configs() returning an empty iterator (Bluetooth HFP transition edge); a contains() match against a phantom/duplicated endpoint.

Common situations: Another conferencing app (Zoom/Teams with exclusive mode) holds the mic; mic disabled after a Windows update; a virtual cable (VB-Cable, VoiceMeeter) half-installed; selecting a Bluetooth headset while it is in A2DP playback mode rather than HFP call mode, so no input formats are exposed.

Related errors

• Failed to create WASAPI host: {}
• Failed to get default input config: {}
• Device not found or no compatible configuration available: {
• Unsupported sample format: {:?}
• Failed to get output config: {}

AI-assisted analysis of Zackriya-Solutions/meetily@0281737d87 (2026-08-16). Data as JSON: /api/errors/d5f52caadba3c031. Report an issue: GitHub.