rlx-mimi 0.2.11

Kyutai Mimi neural audio codec (12.5 Hz, 24 kHz) for RLX
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
107
108
109
110
111
112
113
114
115

use anyhow::Result;
use rlx_runtime::{Device, is_available};

/// Resolve codec execution device (may differ from the requested tag).
pub fn resolve_codec_device(requested: Device) -> Device {
    if requested == Device::Cpu {
        return Device::Cpu;
    }
    #[cfg(feature = "parity-mimi")]
    {
        if candle_codec_available(requested) {
            return requested;
        }
        // Apple MLX tag → Candle Metal kernels on the same GPU.
        if requested == Device::Mlx && candle_codec_available(Device::Metal) {
            return Device::Metal;
        }
    }
    Device::Cpu
}

#[cfg(feature = "parity-mimi")]
pub fn candle_codec_available(device: Device) -> bool {
    match device {
        Device::Metal => candle::utils::metal_is_available(),
        Device::Cuda => candle::utils::cuda_is_available(),
        Device::Mlx
        | Device::Cpu
        | Device::Gpu
        | Device::Vulkan
        | Device::Rocm
        | Device::Ane
        | Device::Tpu
        | Device::OpenGl
        | Device::DirectX
        | Device::WebGpu => false,
    }
}

#[cfg(not(feature = "parity-mimi"))]
pub fn candle_codec_available(_device: Device) -> bool {
    false
}

pub fn parse_mimi_device(name: &str) -> Result<Device> {
    rlx_cli::parse_standard_device("mimi", name)
}

pub fn test_devices() -> Vec<Device> {
    let raw = std::env::var("RLX_MIMI_DEVICES").unwrap_or_else(|_| "cpu".into());
    if raw.eq_ignore_ascii_case("all") {
        return all_compiled_devices();
    }
    raw.split(',')
        .filter_map(|s| {
            let s = s.trim();
            if s.is_empty() {
                None
            } else {
                parse_mimi_device(s).ok()
            }
        })
        .collect()
}

fn all_compiled_devices() -> Vec<Device> {
    // `mut` only needed when a GPU backend feature compiles in push sites below.
    #[cfg(any(
        feature = "metal",
        feature = "mlx",
        feature = "cuda",
        feature = "vulkan"
    ))]
    let mut out = vec![Device::Cpu];
    #[cfg(not(any(
        feature = "metal",
        feature = "mlx",
        feature = "cuda",
        feature = "vulkan"
    )))]
    let out = vec![Device::Cpu];
    #[cfg(feature = "metal")]
    if is_available(Device::Metal) {
        out.push(Device::Metal);
    }
    #[cfg(feature = "mlx")]
    if is_available(Device::Mlx) {
        out.push(Device::Mlx);
    }
    #[cfg(feature = "cuda")]
    if is_available(Device::Cuda) {
        out.push(Device::Cuda);
    }
    #[cfg(feature = "vulkan")]
    if is_available(Device::Vulkan) {
        out.push(Device::Vulkan);
    }
    out
}

pub fn device_ready(device: Device) -> bool {
    if device == Device::Cpu {
        return true;
    }
    #[cfg(feature = "parity-mimi")]
    {
        if candle_codec_available(device) {
            return true;
        }
        if device == Device::Mlx && candle_codec_available(Device::Metal) {
            return true;
        }
    }
    device == Device::Cpu || is_available(device)
}