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

use nom;
use nom::*;
use nom::IResult;
use error;
use macros;
use std::vec;

#[derive(Debug)]
pub enum Sample {
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64)
}

pub type SampleSet = Vec<Sample>;

pub type Channels = Vec<SampleSet>;

pub fn sample(input:&[u8],size:u32) -> IResult<&[u8],Sample> {

  match size {
        8 => {
            le_u8(input).map(|(input,s)|{(input,Sample::U8(s))})
        },
        16 => {
            le_u16(input).map(|(input,s)|{(input,Sample::U16(s))})
        },
        32 => {
            le_u32(input).map(|(input,s)|{(input,Sample::U32(s))})
        }
        64 => {
            le_u64(input).map(|(input,s)|{(input,Sample::U64(s))})
        }
        _ => {
            custom_error!(input,error::UNSUPPORTED_BITS)
        }
    }
}

pub fn channels(input:&[u8],len:usize,num_channels:u32,size:u32) -> IResult<&[u8],Channels> {
    let mut channels:Channels = vec::Vec::with_capacity(num_channels as usize);
    for _ in 0..num_channels {
        channels.push(SampleSet::new());
    }
    let mut next:&[u8] = input;
    let mut temp_sample:Sample;
    let mut used = 0;
    while used < len - size as usize {
        for c in 0..num_channels {
            let ret = sample(next, size);
            if ret.is_err() {
                return Err(ret.err().unwrap());
            }
            let (n, t) = ret.unwrap();
            next = n;
            temp_sample = t;
            channels[c as usize].push(temp_sample);
            used += (size as usize);
        }
    }
    Ok((next,channels))
}