fast_image_resize 6.1.0

Library for fast image resizing with using of SIMD instructions
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

use crate::convolution::optimisations::Normalizer32;
use crate::pixels::InnerPixel;
use crate::{ImageView, ImageViewMut};

#[inline(always)]
pub(crate) fn vert_convolution<T>(
    src_view: &impl ImageView<Pixel = T>,
    dst_view: &mut impl ImageViewMut<Pixel = T>,
    offset: u32,
    normalizer: &Normalizer32,
) where
    T: InnerPixel<Component = u16>,
{
    let coefficients_chunks = normalizer.chunks();
    let precision = normalizer.precision();
    let initial: i64 = 1 << (precision - 1);
    let src_x_initial = offset as usize * T::count_of_components();

    let dst_rows = dst_view.iter_rows_mut(0);
    let coeffs_chunks_iter = coefficients_chunks.iter();
    for (coeffs_chunk, dst_row) in coeffs_chunks_iter.zip(dst_rows) {
        let first_y_src = coeffs_chunk.start;
        let ks = coeffs_chunk.values();
        let dst_components = T::components_mut(dst_row);
        let mut x_src = src_x_initial;

        const CHUNK_SIZE: usize = 16;
        let mut dst_chunks = dst_components.chunks_exact_mut(CHUNK_SIZE);
        for dst_chunk in &mut dst_chunks {
            x_src = convolution_one_chunk::<T, CHUNK_SIZE>(
                src_view,
                normalizer,
                initial,
                dst_chunk,
                x_src,
                first_y_src,
                ks,
            );
        }

        let tail = dst_chunks.into_remainder();
        if !tail.is_empty() {
            convolution_by_u16(src_view, normalizer, initial, tail, x_src, first_y_src, ks);
        }
    }
}

#[inline(always)]
fn convolution_one_chunk<T, const CHUNK_SIZE: usize>(
    src_view: &impl ImageView<Pixel = T>,
    normalizer: &Normalizer32,
    initial: i64,
    dst_chunk: &mut [u16],
    mut x_src: usize,
    first_y_src: u32,
    ks: &[i32],
) -> usize
where
    T: InnerPixel<Component = u16>,
{
    let mut ss = [initial; CHUNK_SIZE];
    let src_rows = src_view.iter_rows(first_y_src);
    let x_end = x_src + CHUNK_SIZE;

    for (k, src_row) in ks.iter().copied().zip(src_rows) {
        let src_components = T::components(src_row);
        let src_chunk: &[u16] = &src_components[x_src..x_end];
        for (s, &c) in ss.iter_mut().zip(src_chunk) {
            *s += c as i64 * (k as i64);
        }
    }

    for (i, s) in ss.iter().copied().enumerate() {
        dst_chunk[i] = normalizer.clip(s);
    }
    x_src += CHUNK_SIZE;
    x_src
}

#[inline(always)]
pub(crate) fn convolution_by_u16<T: InnerPixel<Component = u16>>(
    src_view: &impl ImageView<Pixel = T>,
    normalizer: &Normalizer32,
    initial: i64,
    dst_components: &mut [u16],
    mut x_src: usize,
    first_y_src: u32,
    ks: &[i32],
) -> usize {
    for dst_component in dst_components.iter_mut() {
        let mut ss = initial;
        let src_rows = src_view.iter_rows(first_y_src);
        for (&k, src_row) in ks.iter().zip(src_rows) {
            let src_components = T::components(src_row);
            let src_component = src_components[x_src];
            ss += src_component as i64 * (k as i64);
        }
        *dst_component = normalizer.clip(ss);
        x_src += 1
    }
    x_src
}