pub struct State { /* private fields */ }Implementations§
Source§impl State
impl State
Sourcepub fn new(
channels: usize,
in_rate: usize,
out_rate: usize,
quality: usize,
) -> Result<Self, Error>
pub fn new( channels: usize, in_rate: usize, out_rate: usize, quality: usize, ) -> Result<Self, Error>
Examples found in repository?
examples/testresample.rs (line 19)
9fn main() {
10 let mut rate = 1000;
11 let mut off = 0;
12 let mut avail = INBLOCK as isize;
13
14 let fin: Vec<f32> = (0..INBLOCK * 4)
15 .map(|i| ((i as f32) / PERIOD * 2.0 * PI).sin() * 0.9)
16 .collect();
17 let mut fout = vec![0f32; INBLOCK * 8];
18
19 let mut st = State::new(1, RATE, RATE, 4).unwrap();
20
21 st.set_rate(RATE, rate).unwrap();
22 st.skip_zeros();
23
24 st.set_quality(10).unwrap();
25
26 eprintln!("Quality: {}", st.get_quality());
27
28 let mut data = Vec::new();
29
30 loop {
31 let in_len = avail as usize;
32 let out_len = (in_len * rate + RATE - 1) / RATE;
33
34 let prev_in_len = in_len;
35 let prev_out_len = out_len;
36
37 let (in_len, out_len) = st
38 .process_float(0, &fin[off..off + in_len], &mut fout[..out_len])
39 .unwrap();
40
41 eprintln!(
42 "{} {} {} {} -> {} {}",
43 rate, off, prev_in_len, prev_out_len, in_len, out_len
44 );
45
46 off += in_len as usize;
47 avail += INBLOCK as isize - in_len as isize;
48
49 if off >= INBLOCK {
50 off -= INBLOCK;
51 }
52
53 data.push(fout[..out_len as usize].to_vec());
54
55 rate += 5000;
56 if rate > 128000 {
57 break;
58 }
59
60 st.set_rate(RATE, rate).unwrap();
61 }
62
63 println!("{:#?}", data);
64}Sourcepub fn set_rate(&mut self, in_rate: usize, out_rate: usize) -> Result<(), Error>
pub fn set_rate(&mut self, in_rate: usize, out_rate: usize) -> Result<(), Error>
Examples found in repository?
examples/testresample.rs (line 21)
9fn main() {
10 let mut rate = 1000;
11 let mut off = 0;
12 let mut avail = INBLOCK as isize;
13
14 let fin: Vec<f32> = (0..INBLOCK * 4)
15 .map(|i| ((i as f32) / PERIOD * 2.0 * PI).sin() * 0.9)
16 .collect();
17 let mut fout = vec![0f32; INBLOCK * 8];
18
19 let mut st = State::new(1, RATE, RATE, 4).unwrap();
20
21 st.set_rate(RATE, rate).unwrap();
22 st.skip_zeros();
23
24 st.set_quality(10).unwrap();
25
26 eprintln!("Quality: {}", st.get_quality());
27
28 let mut data = Vec::new();
29
30 loop {
31 let in_len = avail as usize;
32 let out_len = (in_len * rate + RATE - 1) / RATE;
33
34 let prev_in_len = in_len;
35 let prev_out_len = out_len;
36
37 let (in_len, out_len) = st
38 .process_float(0, &fin[off..off + in_len], &mut fout[..out_len])
39 .unwrap();
40
41 eprintln!(
42 "{} {} {} {} -> {} {}",
43 rate, off, prev_in_len, prev_out_len, in_len, out_len
44 );
45
46 off += in_len as usize;
47 avail += INBLOCK as isize - in_len as isize;
48
49 if off >= INBLOCK {
50 off -= INBLOCK;
51 }
52
53 data.push(fout[..out_len as usize].to_vec());
54
55 rate += 5000;
56 if rate > 128000 {
57 break;
58 }
59
60 st.set_rate(RATE, rate).unwrap();
61 }
62
63 println!("{:#?}", data);
64}pub fn get_rate(&self) -> (usize, usize)
pub fn get_ratio(&self) -> (usize, usize)
Sourcepub fn process_float(
&mut self,
index: usize,
input: &[f32],
output: &mut [f32],
) -> Result<(usize, usize), Error>
pub fn process_float( &mut self, index: usize, input: &[f32], output: &mut [f32], ) -> Result<(usize, usize), Error>
Examples found in repository?
examples/testresample.rs (line 38)
9fn main() {
10 let mut rate = 1000;
11 let mut off = 0;
12 let mut avail = INBLOCK as isize;
13
14 let fin: Vec<f32> = (0..INBLOCK * 4)
15 .map(|i| ((i as f32) / PERIOD * 2.0 * PI).sin() * 0.9)
16 .collect();
17 let mut fout = vec![0f32; INBLOCK * 8];
18
19 let mut st = State::new(1, RATE, RATE, 4).unwrap();
20
21 st.set_rate(RATE, rate).unwrap();
22 st.skip_zeros();
23
24 st.set_quality(10).unwrap();
25
26 eprintln!("Quality: {}", st.get_quality());
27
28 let mut data = Vec::new();
29
30 loop {
31 let in_len = avail as usize;
32 let out_len = (in_len * rate + RATE - 1) / RATE;
33
34 let prev_in_len = in_len;
35 let prev_out_len = out_len;
36
37 let (in_len, out_len) = st
38 .process_float(0, &fin[off..off + in_len], &mut fout[..out_len])
39 .unwrap();
40
41 eprintln!(
42 "{} {} {} {} -> {} {}",
43 rate, off, prev_in_len, prev_out_len, in_len, out_len
44 );
45
46 off += in_len as usize;
47 avail += INBLOCK as isize - in_len as isize;
48
49 if off >= INBLOCK {
50 off -= INBLOCK;
51 }
52
53 data.push(fout[..out_len as usize].to_vec());
54
55 rate += 5000;
56 if rate > 128000 {
57 break;
58 }
59
60 st.set_rate(RATE, rate).unwrap();
61 }
62
63 println!("{:#?}", data);
64}Sourcepub fn skip_zeros(&mut self)
pub fn skip_zeros(&mut self)
Examples found in repository?
examples/testresample.rs (line 22)
9fn main() {
10 let mut rate = 1000;
11 let mut off = 0;
12 let mut avail = INBLOCK as isize;
13
14 let fin: Vec<f32> = (0..INBLOCK * 4)
15 .map(|i| ((i as f32) / PERIOD * 2.0 * PI).sin() * 0.9)
16 .collect();
17 let mut fout = vec![0f32; INBLOCK * 8];
18
19 let mut st = State::new(1, RATE, RATE, 4).unwrap();
20
21 st.set_rate(RATE, rate).unwrap();
22 st.skip_zeros();
23
24 st.set_quality(10).unwrap();
25
26 eprintln!("Quality: {}", st.get_quality());
27
28 let mut data = Vec::new();
29
30 loop {
31 let in_len = avail as usize;
32 let out_len = (in_len * rate + RATE - 1) / RATE;
33
34 let prev_in_len = in_len;
35 let prev_out_len = out_len;
36
37 let (in_len, out_len) = st
38 .process_float(0, &fin[off..off + in_len], &mut fout[..out_len])
39 .unwrap();
40
41 eprintln!(
42 "{} {} {} {} -> {} {}",
43 rate, off, prev_in_len, prev_out_len, in_len, out_len
44 );
45
46 off += in_len as usize;
47 avail += INBLOCK as isize - in_len as isize;
48
49 if off >= INBLOCK {
50 off -= INBLOCK;
51 }
52
53 data.push(fout[..out_len as usize].to_vec());
54
55 rate += 5000;
56 if rate > 128000 {
57 break;
58 }
59
60 st.set_rate(RATE, rate).unwrap();
61 }
62
63 println!("{:#?}", data);
64}pub fn reset(&mut self)
pub fn get_input_latency(&self) -> usize
pub fn get_output_latency(&self) -> usize
Sourcepub fn set_quality(&mut self, quality: usize) -> Result<(), Error>
pub fn set_quality(&mut self, quality: usize) -> Result<(), Error>
Examples found in repository?
examples/testresample.rs (line 24)
9fn main() {
10 let mut rate = 1000;
11 let mut off = 0;
12 let mut avail = INBLOCK as isize;
13
14 let fin: Vec<f32> = (0..INBLOCK * 4)
15 .map(|i| ((i as f32) / PERIOD * 2.0 * PI).sin() * 0.9)
16 .collect();
17 let mut fout = vec![0f32; INBLOCK * 8];
18
19 let mut st = State::new(1, RATE, RATE, 4).unwrap();
20
21 st.set_rate(RATE, rate).unwrap();
22 st.skip_zeros();
23
24 st.set_quality(10).unwrap();
25
26 eprintln!("Quality: {}", st.get_quality());
27
28 let mut data = Vec::new();
29
30 loop {
31 let in_len = avail as usize;
32 let out_len = (in_len * rate + RATE - 1) / RATE;
33
34 let prev_in_len = in_len;
35 let prev_out_len = out_len;
36
37 let (in_len, out_len) = st
38 .process_float(0, &fin[off..off + in_len], &mut fout[..out_len])
39 .unwrap();
40
41 eprintln!(
42 "{} {} {} {} -> {} {}",
43 rate, off, prev_in_len, prev_out_len, in_len, out_len
44 );
45
46 off += in_len as usize;
47 avail += INBLOCK as isize - in_len as isize;
48
49 if off >= INBLOCK {
50 off -= INBLOCK;
51 }
52
53 data.push(fout[..out_len as usize].to_vec());
54
55 rate += 5000;
56 if rate > 128000 {
57 break;
58 }
59
60 st.set_rate(RATE, rate).unwrap();
61 }
62
63 println!("{:#?}", data);
64}Sourcepub fn get_quality(&self) -> usize
pub fn get_quality(&self) -> usize
Examples found in repository?
examples/testresample.rs (line 26)
9fn main() {
10 let mut rate = 1000;
11 let mut off = 0;
12 let mut avail = INBLOCK as isize;
13
14 let fin: Vec<f32> = (0..INBLOCK * 4)
15 .map(|i| ((i as f32) / PERIOD * 2.0 * PI).sin() * 0.9)
16 .collect();
17 let mut fout = vec![0f32; INBLOCK * 8];
18
19 let mut st = State::new(1, RATE, RATE, 4).unwrap();
20
21 st.set_rate(RATE, rate).unwrap();
22 st.skip_zeros();
23
24 st.set_quality(10).unwrap();
25
26 eprintln!("Quality: {}", st.get_quality());
27
28 let mut data = Vec::new();
29
30 loop {
31 let in_len = avail as usize;
32 let out_len = (in_len * rate + RATE - 1) / RATE;
33
34 let prev_in_len = in_len;
35 let prev_out_len = out_len;
36
37 let (in_len, out_len) = st
38 .process_float(0, &fin[off..off + in_len], &mut fout[..out_len])
39 .unwrap();
40
41 eprintln!(
42 "{} {} {} {} -> {} {}",
43 rate, off, prev_in_len, prev_out_len, in_len, out_len
44 );
45
46 off += in_len as usize;
47 avail += INBLOCK as isize - in_len as isize;
48
49 if off >= INBLOCK {
50 off -= INBLOCK;
51 }
52
53 data.push(fout[..out_len as usize].to_vec());
54
55 rate += 5000;
56 if rate > 128000 {
57 break;
58 }
59
60 st.set_rate(RATE, rate).unwrap();
61 }
62
63 println!("{:#?}", data);
64}Auto Trait Implementations§
impl Freeze for State
impl RefUnwindSafe for State
impl Send for State
impl Sync for State
impl Unpin for State
impl UnwindSafe for State
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more