wav1c 0.2.0

Wondrous AV1 encoder written in safe Rust.
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

#[derive(Clone, Copy)]
pub struct DequantValues {
    pub dc: u32,
    pub ac: u32,
}

const DQ_TABLE_8BIT: [[u16; 2]; 256] = [
    [4, 4], [8, 8], [8, 9], [9, 10],
    [10, 11], [11, 12], [12, 13], [12, 14],
    [13, 15], [14, 16], [15, 17], [16, 18],
    [17, 19], [18, 20], [19, 21], [19, 22],
    [20, 23], [21, 24], [22, 25], [23, 26],
    [24, 27], [25, 28], [26, 29], [26, 30],
    [27, 31], [28, 32], [29, 33], [30, 34],
    [31, 35], [32, 36], [32, 37], [33, 38],
    [34, 39], [35, 40], [36, 41], [37, 42],
    [38, 43], [38, 44], [39, 45], [40, 46],
    [41, 47], [42, 48], [43, 49], [43, 50],
    [44, 51], [45, 52], [46, 53], [47, 54],
    [48, 55], [48, 56], [49, 57], [50, 58],
    [51, 59], [52, 60], [53, 61], [53, 62],
    [54, 63], [55, 64], [56, 65], [57, 66],
    [57, 67], [58, 68], [59, 69], [60, 70],
    [61, 71], [62, 72], [62, 73], [63, 74],
    [64, 75], [65, 76], [66, 77], [66, 78],
    [67, 79], [68, 80], [69, 81], [70, 82],
    [70, 83], [71, 84], [72, 85], [73, 86],
    [74, 87], [74, 88], [75, 89], [76, 90],
    [77, 91], [78, 92], [78, 93], [79, 94],
    [80, 95], [81, 96], [81, 97], [82, 98],
    [83, 99], [84, 100], [85, 101], [85, 102],
    [87, 104], [88, 106], [90, 108], [92, 110],
    [93, 112], [95, 114], [96, 116], [98, 118],
    [99, 120], [101, 122], [102, 124], [104, 126],
    [105, 128], [107, 130], [108, 132], [110, 134],
    [111, 136], [113, 138], [114, 140], [116, 142],
    [117, 144], [118, 146], [120, 148], [121, 150],
    [123, 152], [125, 155], [127, 158], [129, 161],
    [131, 164], [134, 167], [136, 170], [138, 173],
    [140, 176], [142, 179], [144, 182], [146, 185],
    [148, 188], [150, 191], [152, 194], [154, 197],
    [156, 200], [158, 203], [161, 207], [164, 211],
    [166, 215], [169, 219], [172, 223], [174, 227],
    [177, 231], [180, 235], [182, 239], [185, 243],
    [187, 247], [190, 251], [192, 255], [195, 260],
    [199, 265], [202, 270], [205, 275], [208, 280],
    [211, 285], [214, 290], [217, 295], [220, 300],
    [223, 305], [226, 311], [230, 317], [233, 323],
    [237, 329], [240, 335], [243, 341], [247, 347],
    [250, 353], [253, 359], [257, 366], [261, 373],
    [265, 380], [269, 387], [272, 394], [276, 401],
    [280, 408], [284, 416], [288, 424], [292, 432],
    [296, 440], [300, 448], [304, 456], [309, 465],
    [313, 474], [317, 483], [322, 492], [326, 501],
    [330, 510], [335, 520], [340, 530], [344, 540],
    [349, 550], [354, 560], [359, 571], [364, 582],
    [369, 593], [374, 604], [379, 615], [384, 627],
    [389, 639], [395, 651], [400, 663], [406, 676],
    [411, 689], [417, 702], [423, 715], [429, 729],
    [435, 743], [441, 757], [447, 771], [454, 786],
    [461, 801], [467, 816], [475, 832], [482, 848],
    [489, 864], [497, 881], [505, 898], [513, 915],
    [522, 933], [530, 951], [539, 969], [549, 988],
    [559, 1007], [569, 1026], [579, 1046], [590, 1066],
    [602, 1087], [614, 1108], [626, 1129], [640, 1151],
    [654, 1173], [668, 1196], [684, 1219], [700, 1243],
    [717, 1267], [736, 1292], [755, 1317], [775, 1343],
    [796, 1369], [819, 1396], [843, 1423], [869, 1451],
    [896, 1479], [925, 1508], [955, 1537], [988, 1567],
    [1022, 1597], [1058, 1628], [1098, 1660], [1139, 1692],
    [1184, 1725], [1232, 1759], [1282, 1793], [1336, 1828],
];

pub fn lookup_dequant(base_q_idx: u8) -> DequantValues {
    let entry = DQ_TABLE_8BIT[base_q_idx as usize];
    DequantValues {
        dc: entry[0] as u32,
        ac: entry[1] as u32,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn q128_matches_previous_hardcoded_values() {
        let dq = lookup_dequant(128);
        assert_eq!(dq.dc, 140);
        assert_eq!(dq.ac, 176);
    }

    #[test]
    fn q0_is_lowest_dequant() {
        let dq = lookup_dequant(0);
        assert_eq!(dq.dc, 4);
        assert_eq!(dq.ac, 4);
    }

    #[test]
    fn q255_is_highest_dequant() {
        let dq = lookup_dequant(255);
        assert_eq!(dq.dc, 1336);
        assert_eq!(dq.ac, 1828);
    }

    #[test]
    fn dequant_increases_monotonically() {
        for i in 1..=255u8 {
            let prev = lookup_dequant(i - 1);
            let curr = lookup_dequant(i);
            assert!(curr.dc >= prev.dc, "DC not monotonic at q_idx={}", i);
            assert!(curr.ac >= prev.ac, "AC not monotonic at q_idx={}", i);
        }
    }
}