nanomp3

https://docs.rs/nanomp3/0.1.1
Admin
nanomp3 is the core MP3 decoder, with no internal buffering.
Tokens:173,304
Snippets:452
Trust Score:9.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### Initialize mp3dec_t structure

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes the mp3dec_t structure by setting the first byte of the header to 0. This is a basic setup function.

```rust
pub const unsafe fn mp3dec_init(mut dec: *mut mp3dec_t) {
    (*dec).header[0 as i32 as usize] = 0 as i32 as u8;
}
```

--------------------------------

### Discrete Cosine Transform (DCT-III) Initialization

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html?search=

Initializes variables for a Discrete Cosine Transform (DCT-III) operation on audio data. This snippet shows the setup for the first few sample points.

```rust
unsafe fn L3_dct3_9(mut y: *mut f32) {
    let mut s0: f32 = 0.;
    let mut s1: f32 = 0.;
    let mut s2: f32 = 0.;
    let mut s3: f32 = 0.;
    let mut s4: f32 = 0.;
    let mut s5: f32 = 0.;
    let mut s6: f32 = 0.;
    let mut s7: f32 = 0.;
    let mut s8: f32 = 0.;
    let mut t0: f32 = 0.;
    let mut t2: f32 = 0.;
    let mut t4: f32 = 0.;
    s0 = *y.offset(0 as i32 as isize);
}
```

--------------------------------

### Instantiate Decoder

Source: https://docs.rs/nanomp3/0.1.1/nanomp3/struct.Decoder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new instance of the Decoder. This is the primary way to get a Decoder object for use.

```rust
let decoder = Decoder::new();
```

--------------------------------

### Initialize nanomp3 Decoder

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/lib.rs.html

Instantiates a new `Decoder`. This is the primary entry point for decoding MP3 data.

```rust
pub const MAX_SAMPLES_PER_FRAME: usize = 1152*2;

pub struct Decoder(minimp3::mp3dec_t);

impl Decoder {
    /// Instantiates a `Decoder`.
    pub const fn new() -> Self {
        Self(minimp3::mp3dec_t::new())
    }

    // ... other methods
}

impl Default for Decoder {
    fn default() -> Self {
        Self::new()
    }
}
```

--------------------------------

### Instantiate Decoder

Source: https://docs.rs/nanomp3/0.1.1/nanomp3/struct.Decoder.html

Creates a new instance of the MP3 Decoder. This decoder has no internal buffering.

```rust
pub struct Decoder(/* private fields */);
```

--------------------------------

### Get Bits from Bitstream

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Reads a specified number of bits from the bitstream buffer. Returns 0 if the read exceeds the buffer limit.

```rust
unsafe fn get_bits(mut bs: *mut bs_t, mut n: i32) -> uint32_t {
    let mut next: uint32_t = 0;
    let mut cache: uint32_t = 0 as i32 as uint32_t;
    let mut s: uint32_t = ((*bs).pos & 7 as i32) as uint32_t;
    let mut shl: i32 = (n as uint32_t).wrapping_add(s) as i32;
    let mut p: *const uint8_t = ((*bs).buf)
        .offset(((*bs).pos >> 3 as i32) as isize);
    (*bs).pos += n;
    if (*bs).pos > (*bs).limit {
        return 0 as i32 as uint32_t;
    }
    let fresh0 = p;
    p = p.offset(1);
    next = (*fresh0 as i32 & 255 as i32 >> s) as uint32_t;
    loop {
        shl -= 8 as i32;
        if !(shl > 0 as i32) {
            break;
        }
        cache |= next << shl;
        let fresh1 = p;
        p = p.offset(1);
        next = *fresh1 as uint32_t;
    }
    return cache | next >> -shl;
}
```

--------------------------------

### Channels Enum and Methods

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/lib.rs.html?search=u32+-%3E+bool

Defines the possible channel formats (Mono, Stereo) for MP3 frames and provides a method to get the number of channels.

```rust
pub enum Channels {
    Mono = 1,
    Stereo
}

impl Channels {
    /// Returns the corresponding number of channels for `self`.
    pub fn num(self) -> u8 {
        self as u8
    }
}
```

--------------------------------

### Audio Sample Data Initialization

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes a large array of f32 audio samples, likely for a lookup table or buffer. Values are cast from i32 to f32.

```rust
        -(63 as i32) as f32,
        154 as i32 as f32,
        221 as i32 as f32,
        36 as i32 as f32,
        -(1064 as i32) as f32,
        1962 as i32 as f32,
        1280 as i32 as f32,
        2006 as i32 as f32,
        -(8209 as i32) as f32,
        9750 as i32 as f32,
        -(998 as i32) as f32,
        21189 as i32 as f32,
        -(53534 as i32) as f32,
        71420 as i32 as f32,
        -(2 as i32) as f32,
        10 as i32 as f32,
        -(68 as i32) as f32,
        147 as i32 as f32,
        215 as i32 as f32,
        2 as i32 as f32,
        -(1137 as i32) as f32,
        1919 as i32 as f32,
        1131 as i32 as f32,
        1692 as i32 as f32,
        -(8491 as i32) as f32,
        9863 as i32 as f32,
        -(2122 as i32) as f32,
        19478 as i32 as f32,
        -(55178 as i32) as f32,
        70590 as i32 as f32,
        -(3 as i32) as f32,
        9 as i32 as f32,
        -(73 as i32) as f32,
        139 as i32 as f32,
        208 as i32 as f32,
        -(29 as i32) as f32,
        -(1210 as i32) as f32,
        1870 as i32 as f32,
        970 as i32 as f32,
        1388 as i32 as f32,
        -(8755 as i32) as f32,
        9935 as i32 as f32,
        -(3300 as i32) as f32,
        17799 as i32 as f32,
        -(56778 as i32) as f32,
        69679 as i32 as f32,
        -(3 as i32) as f32,
        8 as i32 as f32,
        -(79 as i32) as f32,
        132 as i32 as f32,
        200 as i32 as f32,
        -(57 as i32) as f32,
        -(1283 as i32) as f32,
        1817 as i32 as f32,
        794 as i32 as f32,
        1095 as i32 as f32,
        -(8998 as i32) as f32,
        9966 as i32 as f32,
        -(4533 as i32) as f32,
        16155 as i32 as f32,
        -(58333 as i32) as f32,
        68692 as i32 as f32,
        -(4 as i32) as f32,
        7 as i32 as f32,
        -(85 as i32) as f32,
        125 as i32 as f32,
        189 as i32 as f32,
        -(83 as i32) as f32,
        -(1356 as i32) as f32,
        1759 as i32 as f32,
        605 as i32 as f32,
        814 as i32 as f32,
        -(9219 as i32) as f32,
        9959 as i32 as f32,
        -(5818 as i32) as f32,
        14548 as i32 as f32,
        -(59838 as i32) as f32,
        67629 as i32 as f32,
        -(4 as i32) as f32,
        7 as i32 as f32,
        -(91 as i32) as f32,
        117 as i32 as f32,
        177 as i32 as f32,
        -(106 as i32) as f32,
        -(1428 as i32) as f32,
        1698 as i32 as f32,
        402 as i32 as f32,
        545 as i32 as f32,
        -(9416 as i32) as f32,
        9916 as i32 as f32,
        -(7154 as i32) as f32,
        12980 as i32 as f32,
        -(61289 as i32) as f32,
        66494 as i32 as f32,
        -(5 as i32) as f32,
        6 as i32 as f32,
        -(97 as i32) as f32,
        111 as i32 as f32,
        163 as i32 as f32,
        -(127 as i32) as f32,
        -(1498 as i32) as f32,
        1634 as i32 as f32,
        185 as i32 as f32,
        288 as i32 as f32,
        -(9585 as i32) as f32,
        9838 as i32 as f32,
        -(8540 as i32) as f32,
        11455 as i32 as f32,
        -(62684 as i32) as f32,
        65290 as i32 as f32
    ]
```

--------------------------------

### Get Number of Channels

Source: https://docs.rs/nanomp3/0.1.1/nanomp3/enum.Channels.html?search=u32+-%3E+bool

Returns the corresponding number of channels for a given `Channels` variant. This method is useful for determining the channel count of an audio stream.

```rust
pub fn num(self) -> u8
```

--------------------------------

### MP3 Frame Finding Logic

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Locates the start of valid MP3 frames within a byte buffer. It handles free format and standard frame detection.

```rust
unsafe fn mp3d_find_frame(
    mut mp3: *const uint8_t,
    mut mp3_bytes: i32,
    mut free_format_bytes: *mut i32,
    mut ptr_frame_bytes: *mut i32,
) -> i32 {
    let mut i: i32 = 0;
    let mut k: i32 = 0;
    i = 0 as i32;
    while i < mp3_bytes - 4 as i32 {
        if hdr_valid(mp3) != 0 {
            let mut frame_bytes: i32 = hdr_frame_bytes(mp3, *free_format_bytes);
            let mut frame_and_padding: i32 = frame_bytes + hdr_padding(mp3);
            k = 4 as i32;
            while frame_bytes == 0 && k < 2304 as i32 && i + 2 as i32 * k < mp3_bytes - 4 as i32 {
                if hdr_compare(mp3, mp3.offset(k as isize)) != 0 {
                    let mut fb: i32 = k - hdr_padding(mp3);
                    let mut nextfb: i32 = fb + hdr_padding(mp3.offset(k as isize));
                    if !(i + k + nextfb + 4 as i32 > mp3_bytes || hdr_compare(mp3, mp3.offset(k as isize).offset(nextfb as isize)) == 0) {
                        frame_and_padding = k;
                        frame_bytes = fb;
                        *free_format_bytes = fb;
                    }
                }
                k += 1;
            }
        }
        i += 1;
    }
    return 0 as i32;
}
```

--------------------------------

### Audio Sample Data Initialization

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html?search=u32+-%3E+bool

Initializes a large array of f32 values representing audio samples. These values are derived from i32 casts and conversions to f32.

```rust
let lins: [f32; 64] = [
        -(63 as i32) as f32,
        154 as i32 as f32,
        221 as i32 as f32,
        36 as i32 as f32,
        -(1064 as i32) as f32,
        1962 as i32 as f32,
        1280 as i32 as f32,
        2006 as i32 as f32,
        -(8209 as i32) as f32,
        9750 as i32 as f32,
        -(998 as i32) as f32,
        21189 as i32 as f32,
        -(53534 as i32) as f32,
        71420 as i32 as f32,
        -(2 as i32) as f32,
        10 as i32 as f32,
        -(68 as i32) as f32,
        147 as i32 as f32,
        215 as i32 as f32,
        2 as i32 as f32,
        -(1137 as i32) as f32,
        1919 as i32 as f32,
        1131 as i32 as f32,
        1692 as i32 as f32,
        -(8491 as i32) as f32,
        9863 as i32 as f32,
        -(2122 as i32) as f32,
        19478 as i32 as f32,
        -(55178 as i32) as f32,
        70590 as i32 as f32,
        -(3 as i32) as f32,
        9 as i32 as f32,
        -(73 as i32) as f32,
        139 as i32 as f32,
        208 as i32 as f32,
        -(29 as i32) as f32,
        -(1210 as i32) as f32,
        1870 as i32 as f32,
        970 as i32 as f32,
        1388 as i32 as f32,
        -(8755 as i32) as f32,
        9935 as i32 as f32,
        -(3300 as i32) as f32,
        17799 as i32 as f32,
        -(56778 as i32) as f32,
        69679 as i32 as f32,
        -(3 as i32) as f32,
        8 as i32 as f32,
        -(79 as i32) as f32,
        132 as i32 as f32,
        200 as i32 as f32,
        -(57 as i32) as f32,
        -(1283 as i32) as f32,
        1817 as i32 as f32,
        794 as i32 as f32,
        1095 as i32 as f32,
        -(8998 as i32) as f32,
        9966 as i32 as f32,
        -(4533 as i32) as f32,
        16155 as i32 as f32,
        -(58333 as i32) as f32,
        68692 as i32 as f32,
        -(4 as i32) as f32,
        7 as i32 as f32,
        -(85 as i32) as f32,
        125 as i32 as f32,
        189 as i32 as f32,
        -(83 as i32) as f32,
        -(1356 as i32) as f32,
        1759 as i32 as f32,
        605 as i32 as f32,
        814 as i32 as f32,
        -(9219 as i32) as f32,
        9959 as i32 as f32,
        -(5818 as i32) as f32,
        14548 as i32 as f32,
        -(59838 as i32) as f32,
        67629 as i32 as f32,
        -(4 as i32) as f32,
        7 as i32 as f32,
        -(91 as i32) as f32,
        117 as i32 as f32,
        177 as i32 as f32,
        -(106 as i32) as f32,
        -(1428 as i32) as f32,
        1698 as i32 as f32,
        402 as i32 as f32,
        545 as i32 as f32,
        -(9416 as i32) as f32,
        9916 as i32 as f32,
        -(7154 as i32) as f32,
        12980 as i32 as f32,
        -(61289 as i32) as f32,
        66494 as i32 as f32,
        -(5 as i32) as f32,
        6 as i32 as f32,
        -(97 as i32) as f32,
        111 as i32 as f32,
        163 as i32 as f32,
        -(127 as i32) as f32,
        -(1498 as i32) as f32,
        1634 as i32 as f32,
        185 as i32 as f32,
        288 as i32 as f32,
        -(9585 as i32) as f32,
        9838 as i32 as f32,
        -(8540 as i32) as f32,
        11455 as i32 as f32,
        -(62684 as i32) as f32,
        65290 as i32 as f32
    ];
```

--------------------------------

### MP3 Header Bitrate Calculation

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Calculates the bitrate in kilobits per second from an MP3 header. This snippet is incomplete, showing only the start of the halfrate lookup table.

```rust
unsafe fn hdr_bitrate_kbps(mut h: *const uint8_t) -> u32 {
     static halfrate: [[[uint8_t; 15]; 3]; 2] = [
        [
            [
                0 as i32 as uint8_t,
                4 as i32 as uint8_t,
                8 as i32 as uint8_t,
                12 as i32 as uint8_t,

```

--------------------------------

### Instantiate and Decode MP3 Data with nanomp3

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Instantiates a Decoder and decodes MP3 data into a PCM buffer. Ensure the PCM buffer is at least MAX_SAMPLES_PER_FRAME long. The mp3 data buffer should ideally be 16KiB for better performance.

```rust
1#![no_std]
2
3mod minimp3;
4
5/// The minimum length of the PCM output buffer.
6pub const MAX_SAMPLES_PER_FRAME: usize = 1152*2;
7
8/// The core MP3 decoder, with no internal buffering.
9pub struct Decoder(minimp3::mp3dec_t);
10
11
12/// The channel formats that may be encoded in an MP3 frame.
13#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
14pub enum Channels {
15    Mono = 1,
16    Stereo
17}
18
19impl Channels {
20    /// Returns the corresponding number of channels for `self`.
21    pub fn num(self) -> u8 {
22        self as u8
23    }
24}
25
26/// Information about the frame decoded by [`Decoder::decode`]
27#[derive(Debug, Clone, Copy)]
28pub struct FrameInfo {
29    /// The number of PCM samples produced.
30    pub samples_produced: usize,
31    /// The number of channels in this frame.
32    pub channels: Channels,
33    /// Sample rate of this frame, in Hz.
34    pub sample_rate: u32,
35    /// The current MP3 bit rate, in kilobits per second.
36    pub bitrate: u32
37}
38
39impl Decoder {
40    /// Instantiates a `Decoder`.
41    pub const fn new() -> Self {
42        Self(minimp3::mp3dec_t::new())
43    }
44
45    /// Decode MP3 data into a buffer, returning the amount of MP3 data consumed and info about decoded samples.
46    /// `mp3` should contain at least several frames worth of data at any given time (16KiB recommended) to avoid artifacting.
47    /// 
48    /// # Panics
49    /// 
50    /// Panics if `pcm` is less than [`MAX_SAMPLES_PER_FRAME`] long.
51    pub fn decode(&mut self, mp3: &[u8], pcm: &mut [f32]) -> (usize, Option<FrameInfo>) {
52        assert!(pcm.len() >= MAX_SAMPLES_PER_FRAME, "pcm buffer too small");
53
54        let mut info = minimp3::mp3dec_frame_info_t::default();
55
56        let samples = unsafe { minimp3::mp3dec_decode_frame(
57            &mut self.0,
58            mp3.as_ptr(),
59            mp3.len().try_into().unwrap(),
60            pcm.as_mut_ptr(),
61            &mut info
62        ) };
63
64        (
65            info.frame_bytes.try_into().unwrap(),
66            (samples != 0).then(|| FrameInfo {
67                samples_produced: samples.try_into().unwrap(),
68                channels: match info.channels {
69                    1 => Channels::Mono,
70                    2 => Channels::Stereo,
71                    _ => unreachable!()
72                },
73                sample_rate: info.hz.try_into().unwrap(),
74                bitrate: info.bitrate_kbps.try_into().unwrap()
75            })
76        )
77    }
78}
79
80impl Default for Decoder {
81    fn default() -> Self {
82        Self::new()
83    }
84}
```

--------------------------------

### Get MP3 Header Bitrate

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html

Calculates the bitrate in kilobits per second from an MP3 header. This function uses a lookup table for different MP3 versions and bitrates.

```rust
157unsafe fn hdr_bitrate_kbps(mut h: *const uint8_t) -> u32 {
158     static halfrate: [[[uint8_t; 15]; 3]; 2] = [[
159        [
160            [0 as i32 as uint8_t,
161                4 as i32 as uint8_t,
162                8 as i32 as uint8_t,

```

--------------------------------

### Audio Sample Data Initialization

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html

Initializes a large array of f32 audio samples. These values are likely used in audio synthesis or processing.

```rust
5588        -(63 as i32) as f32,
5589        154 as i32 as f32,
5590        221 as i32 as f32,
5591        36 as i32 as f32,
5592        -(1064 as i32) as f32,
5593        1962 as i32 as f32,
5594        1280 as i32 as f32,
5595        2006 as i32 as f32,
5596        -(8209 as i32) as f32,
5597        9750 as i32 as f32,
5598        -(998 as i32) as f32,
5599        21189 as i32 as f32,
5600        -(53534 as i32) as f32,
5601        71420 as i32 as f32,
5602        -(2 as i32) as f32,
5603        10 as i32 as f32,
5604        -(68 as i32) as f32,
5605        147 as i32 as f32,
5606        215 as i32 as f32,
5607        2 as i32 as f32,
5608        -(1137 as i32) as f32,
5609        1919 as i32 as f32,
5610        1131 as i32 as f32,
5611        1692 as i32 as f32,
5612        -(8491 as i32) as f32,
5613        9863 as i32 as f32,
5614        -(2122 as i32) as f32,
5615        19478 as i32 as f32,
5616        -(55178 as i32) as f32,
5617        70590 as i32 as f32,
5618        -(3 as i32) as f32,
5619        9 as i32 as f32,
5620        -(73 as i32) as f32,
5621        139 as i32 as f32,
5622        208 as i32 as f32,
5623        -(29 as i32) as f32,
5624        -(1210 as i32) as f32,
5625        1870 as i32 as f32,
5626        970 as i32 as f32,
5627        1388 as i32 as f32,
5628        -(8755 as i32) as f32,
5629        9935 as i32 as f32,
5630        -(3300 as i32) as f32,
5631        17799 as i32 as f32,
5632        -(56778 as i32) as f32,
5633        69679 as i32 as f32,
5634        -(3 as i32) as f32,
5635        8 as i32 as f32,
5636        -(79 as i32) as f32,
5637        132 as i32 as f32,
5638        200 as i32 as f32,
5639        -(57 as i32) as f32,
5640        -(1283 as i32) as f32,
5641        1817 as i32 as f32,
5642        794 as i32 as f32,
5643        1095 as i32 as f32,
5644        -(8998 as i32) as f32,
5645        9966 as i32 as f32,
5646        -(4533 as i32) as f32,
5647        16155 as i32 as f32,
5648        -(58333 as i32) as f32,
5649        68692 as i32 as f32,
5650        -(4 as i32) as f32,
5651        7 as i32 as f32,
5652        -(85 as i32) as f32,
5653        125 as i32 as f32,
5654        189 as i32 as f32,
5655        -(83 as i32) as f32,
5656        -(1356 as i32) as f32,
5657        1759 as i32 as f32,
5658        605 as i32 as f32,
5659        814 as i32 as f32,
5660        -(9219 as i32) as f32,
5661        9959 as i32 as f32,
5662        -(5818 as i32) as f32,
5663        14548 as i32 as f32,
5664        -(59838 as i32) as f32,
5665        67629 as i32 as f32,
5666        -(4 as i32) as f32,
5667        7 as i32 as f32,
5668        -(91 as i32) as f32,
5669        117 as i32 as f32,
5670        177 as i32 as f32,
5671        -(106 as i32) as f32,
5672        -(1428 as i32) as f32,
5673        1698 as i32 as f32,
5674        402 as i32 as f32,
5675        545 as i32 as f32,
5676        -(9416 as i32) as f32,
5677        9916 as i32 as f32,
5678        -(7154 as i32) as f32,
5679        12980 as i32 as f32,
5680        -(61289 as i32) as f32,
5681        66494 as i32 as f32,
5682        -(5 as i32) as f32,
5683        6 as i32 as f32,
5684        -(97 as i32) as f32,
5685        111 as i32 as f32,
5686        163 as i32 as f32,
5687        -(127 as i32) as f32,
5688        -(1498 as i32) as f32,
5689        1634 as i32 as f32,
5690        185 as i32 as f32,
5691        288 as i32 as f32,
5692        -(9585 as i32) as f32,
5693        9838 as i32 as f32,
5694        -(8540 as i32) as f32,
5695        11455 as i32 as f32,
5696        -(62684 as i32) as f32,
5697        65290 as i32 as f32
```

--------------------------------

### Initialize Audio Buffer

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html?search=std%3A%3Avec

Initializes a buffer with floating-point audio samples. This is typically used for storing decoded audio data.

```rust
let lins = [
-(63 as i32) as f32,
154 as i32 as f32,
221 as i32 as f32,
36 as i32 as f32,
-(1064 as i32) as f32,
1962 as i32 as f32,
1280 as i32 as f32,
2006 as i32 as f32,
-(8209 as i32) as f32,
9750 as i32 as f32,
-(998 as i32) as f32,
21189 as i32 as f32,
-(53534 as i32) as f32,
71420 as i32 as f32,
-(2 as i32) as f32,
10 as i32 as f32,
-(68 as i32) as f32,
147 as i32 as f32,
215 as i32 as f32,
2 as i32 as f32,
-(1137 as i32) as f32,
1919 as i32 as f32,
1131 as i32 as f32,
1692 as i32 as f32,
-(8491 as i32) as f32,
9863 as i32 as f32,
-(2122 as i32) as f32,
19478 as i32 as f32,
-(55178 as i32) as f32,
70590 as i32 as f32,
-(3 as i32) as f32,
9 as i32 as f32,
-(73 as i32) as f32,
139 as i32 as f32,
208 as i32 as f32,
-(29 as i32) as f32,
-(1210 as i32) as f32,
1870 as i32 as f32,
970 as i32 as f32,
1388 as i32 as f32,
-(8755 as i32) as f32,
9935 as i32 as f32,
-(3300 as i32) as f32,
17799 as i32 as f32,
-(56778 as i32) as f32,
69679 as i32 as f32,
-(3 as i32) as f32,
8 as i32 as f32,
-(79 as i32) as f32,
132 as i32 as f32,
200 as i32 as f32,
-(57 as i32) as f32,
-(1283 as i32) as f32,
1817 as i32 as f32,
794 as i32 as f32,
1095 as i32 as f32,
-(8998 as i32) as f32,
9966 as i32 as f32,
-(4533 as i32) as f32,
16155 as i32 as f32,
-(58333 as i32) as f32,
68692 as i32 as f32,
-(4 as i32) as f32,
7 as i32 as f32,
-(85 as i32) as f32,
125 as i32 as f32,
189 as i32 as f32,
-(83 as i32) as f32,
-(1356 as i32) as f32,
1759 as i32 as f32,
605 as i32 as f32,
814 as i32 as f32,
-(9219 as i32) as f32,
9959 as i32 as f32,
-(5818 as i32) as f32,
14548 as i32 as f32,
-(59838 as i32) as f32,
67629 as i32 as f32,
-(4 as i32) as f32,
7 as i32 as f32,
-(91 as i32) as f32,
117 as i32 as f32,
177 as i32 as f32,
-(106 as i32) as f32,
-(1428 as i32) as f32,
1698 as i32 as f32,
402 as i32 as f32,
545 as i32 as f32,
-(9416 as i32) as f32,
9916 as i32 as f32,
-(7154 as i32) as f32,
12980 as i32 as f32,
-(61289 as i32) as f32,
66494 as i32 as f32,
-(5 as i32) as f32,
6 as i32 as f32,
-(97 as i32) as f32,
111 as i32 as f32,
163 as i32 as f32,
-(127 as i32) as f32,
-(1498 as i32) as f32,
1634 as i32 as f32,
185 as i32 as f32,
288 as i32 as f32,
-(9585 as i32) as f32,
9838 as i32 as f32,
-(8540 as i32) as f32,
11455 as i32 as f32,
-(62684 as i32) as f32,
65290 as i32 as f32
];
```

--------------------------------

### Initialize int16_t array with sample values

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes a static array of int16_t values with specific sample data. This array likely represents audio sample amplitudes.

```rust
648 as i32 as int16_t,
        746 as i32 as int16_t,
        0 as i32 as int16_t,
        1126 as i32 as int16_t,
        1460 as i32 as int16_t,
        1460 as i32 as int16_t,
        1460 as i32 as int16_t,
        1460 as i32 as int16_t,
        1460 as i32 as int16_t,
        1460 as i32 as int16_t,
        1460 as i32 as int16_t,
        1460 as i32 as int16_t,
        1842 as i32 as int16_t,
        1842 as i32 as int16_t,
        1842 as i32 as int16_t,
        1842 as i32 as int16_t,
        1842 as i32 as int16_t,
        1842 as i32 as int16_t,
        1842 as i32 as int16_t,
        1842 as i32 as int16_t,
```

--------------------------------

### Unwrapping Option with Default Value

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to get the value out of an `Option` or provide a default value if the `Option` is `None` using `unwrap_or`. This is a common way to handle optional values when a fallback is acceptable.

```rust
let x = Some(2);
let y = x.unwrap_or(0);
// y is 2
```

```rust
let x: Option<i32> = None;
let y = x.unwrap_or(0);
// y is 0
```

--------------------------------

### MP3 Decoder Initialization

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html

Provides a constant-time constructor `new` for the `mp3dec_t` structure, initializing all fields to default values.

```rust
42    pub const fn new() -> Self {
43        Self {
44            mdct_overlap: [[0.; 288]; 2],
45            qmf_state: [0.; 960],
46            reserv: 0,
47            free_format_bytes: 0,
48            header: [0; 4],
49            reserv_buf: [0; 511]
50        }
51    }
```

--------------------------------

### Find MP3 Frame

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html

Scans MP3 data to find the start of a valid frame, considering potential free format bytes and comparing headers. It attempts to locate frame boundaries and validate them.

```rust
unsafe fn mp3d_find_frame(
    mut mp3: *const uint8_t,
    mut mp3_bytes: i32,
    mut free_format_bytes: *mut i32,
    mut ptr_frame_bytes: *mut i32,
) -> i32 {
    let mut i: i32 = 0;
    let mut k: i32 = 0;
    i = 0 as i32;
    while i < mp3_bytes - 4 as i32 {
        if hdr_valid(mp3) != 0 {
            let mut frame_bytes: i32 = hdr_frame_bytes(mp3, *free_format_bytes);
            let mut frame_and_padding: i32 = frame_bytes + hdr_padding(mp3);
            k = 4 as i32;
            while frame_bytes == 0 && k < 2304 as i32
                && i + 2 as i32 * k < mp3_bytes - 4 as i32
            {
                if hdr_compare(mp3, mp3.offset(k as isize)) != 0 {
                    let mut fb: i32 = k - hdr_padding(mp3);
                    let mut nextfb: i32 = fb
                        + hdr_padding(mp3.offset(k as isize));
                    if !(i + k + nextfb + 4 as i32 > mp3_bytes
                        || hdr_compare(
                            mp3,
                            mp3.offset(k as isize).offset(nextfb as isize),
                        ) == 0) {
                        frame_and_padding = k;
                        frame_bytes = fb;
                        *free_format_bytes = fb;
                    }
                }
                k += 1;
            }
        }
    }
    return 0 as i32;
}

```

--------------------------------

### Rust Option map example

Source: https://docs.rs/nanomp3/0.1.1/src/nanomp3/minimp3.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the `map` method on an `Option<T>` to transform the contained value if it exists. This is useful for applying a function to an optional value without needing to explicitly unwrap it.

```rust
unsafe fn L3_imdct36(
    mut grbuf: *mut f32,
    mut overlap: *mut f32,
    mut window: *const f32,
    mut nbands: i32,
) {
    let mut i: i32 = 0;
    let mut j: i32 = 0;
     static g_twid9: [f32; 18] = [
        0.73727734f32,
        0.79335334f32,
        0.84339145f32,
        0.88701083f32,
        0.92387953f32,
        0.95371695f32,
        0.97629601f32,
        0.99144486f32,
        0.99904822f32,
        0.67559021f32,
        0.60876143f32,
        0.53729961f32,
        0.46174861f32,
        0.38268343f32,
        0.30070580f32,
        0.21643961f32,
        0.13052619f32,
        0.04361938f32,
    ];
    j = 0 as i32;
    while j < nbands {
        let mut co: [f32; 9] = [0.; 9];
        let mut si: [f32; 9] = [0.; 9];
        co[0 as i32 as usize] = -*grbuf.offset(0 as i32 as isize);
        si[0 as i32 as usize] = *grbuf.offset(17 as i32 as isize);
        i = 0 as i32;
        while i < 4 as i32 {
            si[(8 as i32 - 2 as i32 * i)
                as usize] = *grbuf
                .offset((4 as i32 * i + 1 as i32) as isize)
                - *grbuf.offset((4 as i32 * i + 2 as i32) as isize);
            co[(1 as i32 + 2 as i32 * i)
                as usize] = *grbuf
                .offset((4 as i32 * i + 1 as i32) as isize)
                + *grbuf.offset((4 as i32 * i + 2 as i32) as isize);
            si[(7 as i32 - 2 as i32 * i)
                as usize] = *grbuf
                .offset((4 as i32 * i + 4 as i32) as isize)
                - *grbuf.offset((4 as i32 * i + 3 as i32) as isize);
            co[(2 as i32 + 2 as i32 * i)
                as usize] = -(*grbuf
                .offset((4 as i32 * i + 3 as i32) as isize)
                + *grbuf.offset((4 as i32 * i + 4 as i32) as isize));
            i += 1;
        }
        L3_dct3_9(co.as_mut_ptr());
        L3_dct3_9(si.as_mut_ptr());
        si[1 as i32 as usize] = -si[1 as i32 as usize];
        si[3 as i32 as usize] = -si[3 as i32 as usize];
        si[5 as i32 as usize] = -si[5 as i32 as usize];
        si[7 as i32 as usize] = -si[7 as i32 as usize];
        i = 0 as i32;
        while i < 9 as i32 {
            let mut ovl: f32 = *overlap.offset(i as isize);
            let mut sum: f32 = co[i as usize]
                * g_twid9[(9 as i32 + i) as usize]
                + si[i as usize] * g_twid9[(0 as i32 + i) as usize];
            *overlap
                .offset(
                    i as isize,
                ) = co[i as usize] * g_twid9[(0 as i32 + i) as usize]
                - si[i as usize] * g_twid9[(9 as i32 + i) as usize];
            *grbuf
                .offset(
                    i as isize,
                ) = ovl * *window.offset((0 as i32 + i) as isize)
                - sum * *window.offset((9 as i32 + i) as isize);
            *grbuf
                .offset(
                    (17 as i32 - i) as isize,
                ) = ovl * *window.offset((9 as i32 + i) as isize)
                + sum * *window.offset((0 as i32 + i) as isize);
            i += 1;
        }
        j += 1;
        grbuf = grbuf.offset(18 as i32 as isize);
        overlap = overlap.offset(9 as i32 as isize);
    }
}
unsafe fn L3_idct3(
    mut x0: f32,
    mut x1: f32,
    mut x2: f32,
    mut dst: *mut f32,
) {
    
}
```
Tokens:
Raw