zenjxl-decoder 0.3.8

High performance Rust implementation of a JPEG XL decoder
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

// Copyright (c) the JPEG XL Project Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

use crate::error::Error;

#[allow(dead_code)] // Container format support infrastructure, currently test-only
pub struct ConcatSlice<'first, 'second> {
    slices: (&'first [u8], &'second [u8]),
    ptr: usize,
}

#[allow(dead_code)]
impl<'first, 'second> ConcatSlice<'first, 'second> {
    pub fn new(slice0: &'first [u8], slice1: &'second [u8]) -> Self {
        Self {
            slices: (slice0, slice1),
            ptr: 0,
        }
    }

    #[allow(clippy::len_without_is_empty)]
    pub fn len(&self) -> usize {
        self.slices.0.len() + self.slices.1.len()
    }

    pub fn remaining_slices(&self) -> (&'first [u8], &'second [u8]) {
        let (slice0, slice1) = self.slices;
        let total_len = self.len();
        let ptr = self.ptr;
        if ptr >= total_len {
            (&[], &[])
        } else if let Some(second_slice_ptr) = ptr.checked_sub(slice0.len()) {
            (&[], &slice1[second_slice_ptr..])
        } else {
            (&slice0[ptr..], slice1)
        }
    }

    pub fn advance(&mut self, bytes: usize) {
        self.ptr += bytes;
    }

    pub fn peek<'out>(&self, out_buf: &'out mut [u8]) -> &'out mut [u8] {
        let (slice0, slice1) = self.remaining_slices();
        let total_len = slice0.len() + slice1.len();

        let out_bytes = out_buf.len().min(total_len);
        let out_buf = &mut out_buf[..out_bytes];

        if out_bytes <= slice0.len() {
            out_buf.copy_from_slice(&slice0[..out_bytes]);
        } else {
            let (out_first, out_second) = out_buf.split_at_mut(slice0.len());
            out_first.copy_from_slice(slice0);
            out_second.copy_from_slice(&slice1[..out_second.len()]);
        }

        out_buf
    }

    pub fn fill_vec(&mut self, max_bytes: Option<usize>, v: &mut Vec<u8>) -> Result<usize, Error> {
        let (slice0, slice1) = self.remaining_slices();
        let total_len = slice0.len() + slice1.len();

        let out_bytes = max_bytes.unwrap_or(usize::MAX).min(total_len);
        v.try_reserve(out_bytes)?;

        if out_bytes <= slice0.len() {
            v.extend_from_slice(&slice0[..out_bytes]);
        } else {
            let second_slice_len = out_bytes - slice0.len();
            v.extend_from_slice(slice0);
            v.extend_from_slice(&slice1[..second_slice_len]);
        }

        self.advance(out_bytes);
        Ok(out_bytes)
    }
}

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

    #[test]
    fn peek_advance() {
        let mut reader = ConcatSlice::new(&[0, 1, 2, 3], &[4, 5, 6, 7]);
        let mut buf = [0u8; 8];

        let actual = reader.peek(&mut buf[..1]);
        assert_eq!(actual, &[0]);
        reader.advance(actual.len());

        let actual = reader.peek(&mut buf[..2]);
        assert_eq!(actual, &[1, 2]);
        reader.advance(actual.len());

        let actual = reader.peek(&mut buf[..3]);
        assert_eq!(actual, &[3, 4, 5]);
        reader.advance(actual.len());

        let actual = reader.peek(&mut buf);
        assert_eq!(actual, &[6, 7]);
        reader.advance(actual.len());

        let actual = reader.peek(&mut buf);
        assert!(actual.is_empty());
    }

    #[test]
    fn fill_vec() {
        let mut reader = ConcatSlice::new(&[0, 1, 2, 3], &[4, 5, 6, 7]);
        let mut v = Vec::new();

        let count = reader.fill_vec(Some(3), &mut v).unwrap();
        assert_eq!(count, 3);
        assert_eq!(&v, &[0, 1, 2]);

        let count = reader.fill_vec(None, &mut v).unwrap();
        assert_eq!(count, 5);
        assert_eq!(&v, &[0, 1, 2, 3, 4, 5, 6, 7]);
    }
}