syom 0.8.0

AAC to planar f32. LC, HE-AAC, AAC-LD. ADTS, M4A, LATM. Zero deps.
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
116
117
118
119
120
121
122
123
124
125

//! MPEG layout slots for [`super::map_planes`] (line cap / TASK-78).

use super::{ElemKind, Element, PceChannelMap, PlaneMap, pce_map, plane};
use crate::engine::error::Result;
use crate::layout::Channel;

/// Map decode-order element planes to output planes (see parent module docs).
#[cfg(test)]
pub(crate) fn map_planes(
    elems: &[Element],
    pce: Option<&PceChannelMap>,
    channel_configuration: u8,
    fs_index: u8,
) -> Result<Vec<PlaneMap>> {
    let mut out = Vec::new();
    map_planes_into(&mut out, elems, pce, channel_configuration, fs_index)?;
    Ok(out)
}

/// Fill `out` (capacity reused). Used-element flags stay on the stack.
pub(crate) fn map_planes_into(
    out: &mut Vec<PlaneMap>,
    elems: &[Element],
    pce: Option<&PceChannelMap>,
    channel_configuration: u8,
    fs_index: u8,
) -> Result<()> {
    out.clear();
    if let Some(p) = pce {
        *out = pce_map(p, elems, fs_index)?;
        return Ok(());
    }
    let n = elems.len().min(16);
    let mut used = [false; 16];
    default_slots_into(out, channel_configuration, elems, &mut used[..n.max(1)]);
    for (i, e) in elems.iter().enumerate() {
        if i < used.len() && !used[i] {
            for p in 0..e.planes() {
                out.push(plane(
                    Some(e.plane + p),
                    e.kind == ElemKind::Lfe,
                    Channel::Other,
                ));
            }
        }
    }
    Ok(())
}

fn default_slots_into(out: &mut Vec<PlaneMap>, config: u8, elems: &[Element], used: &mut [bool]) {
    use ElemKind::{Cpe, Lfe, Sce};
    const L: usize = 0;
    const R: usize = 1;
    let labels = crate::layout::mpeg_channels(config);
    let slots: &[(ElemKind, usize, usize)] = match config {
        1 => &[(Sce, 0, L)],
        2 => &[(Cpe, 0, L), (Cpe, 0, R)],
        3 => &[(Cpe, 0, L), (Cpe, 0, R), (Sce, 0, L)],
        4 => &[(Cpe, 0, L), (Cpe, 0, R), (Sce, 0, L), (Sce, 1, L)],
        5 => &[
            (Cpe, 0, L),
            (Cpe, 0, R),
            (Sce, 0, L),
            (Cpe, 1, L),
            (Cpe, 1, R),
        ],
        6 => &[
            (Cpe, 0, L),
            (Cpe, 0, R),
            (Sce, 0, L),
            (Lfe, 0, L),
            (Cpe, 1, L),
            (Cpe, 1, R),
        ],
        // 7.1: SCE(C) CPE(front) CPE(outside front) CPE(back) LFE ->
        // FL FR FC LFE BL BR SL SR (lavc order; the outside-front pair
        // is the side pair).
        7 => &[
            (Cpe, 0, L),
            (Cpe, 0, R),
            (Sce, 0, L),
            (Lfe, 0, L),
            (Cpe, 2, L),
            (Cpe, 2, R),
            (Cpe, 1, L),
            (Cpe, 1, R),
        ],
        _ => {
            identity_into(out, elems, used);
            return;
        }
    };
    for (i, &(kind, occ, part)) in slots.iter().enumerate() {
        let label = labels.get(i).copied().unwrap_or(Channel::Other);
        let hit = elems
            .iter()
            .enumerate()
            .filter(|(_, e)| e.kind == kind)
            .nth(occ);
        match hit {
            Some((ei, e)) => {
                if ei < used.len() {
                    used[ei] = true;
                }
                out.push(plane(Some(e.plane + part), kind == Lfe, label));
            }
            None => out.push(plane(None, kind == Lfe, label)),
        }
    }
}

fn identity_into(out: &mut Vec<PlaneMap>, elems: &[Element], used: &mut [bool]) {
    for (i, e) in elems.iter().enumerate() {
        if i < used.len() {
            used[i] = true;
        }
        for p in 0..e.planes() {
            out.push(plane(
                Some(e.plane + p),
                e.kind == ElemKind::Lfe,
                Channel::Other,
            ));
        }
    }
}