/rust/registry/src/index.crates.io-1949cf8c6b5b557f/zune-jpeg-0.4.21/src/upsampler.rs
Line | Count | Source |
1 | | /* |
2 | | * Copyright (c) 2023. |
3 | | * |
4 | | * This software is free software; |
5 | | * |
6 | | * You can redistribute it or modify it under terms of the MIT, Apache License or Zlib license |
7 | | */ |
8 | | |
9 | | //! Up-sampling routines |
10 | | //! |
11 | | //! The main upsampling method is a bi-linear interpolation or a "triangle |
12 | | //! filter " or libjpeg turbo `fancy_upsampling` which is a good compromise |
13 | | //! between speed and visual quality |
14 | | //! |
15 | | //! # The filter |
16 | | //! Each output pixel is made from `(3*A+B)/4` where A is the original |
17 | | //! pixel closer to the output and B is the one further. |
18 | | //! |
19 | | //! ```text |
20 | | //!+---+---+ |
21 | | //! | A | B | |
22 | | //! +---+---+ |
23 | | //! +-+-+-+-+ |
24 | | //! | |P| | | |
25 | | //! +-+-+-+-+ |
26 | | //! ``` |
27 | | //! |
28 | | //! # Horizontal Bi-linear filter |
29 | | //! ```text |
30 | | //! |---+-----------+---+ |
31 | | //! | | | | |
32 | | //! | A | |p1 | p2| | B | |
33 | | //! | | | | |
34 | | //! |---+-----------+---+ |
35 | | //! |
36 | | //! ``` |
37 | | //! For a horizontal bi-linear it's trivial to implement, |
38 | | //! |
39 | | //! `A` becomes the input closest to the output. |
40 | | //! |
41 | | //! `B` varies depending on output. |
42 | | //! - For odd positions, input is the `next` pixel after A |
43 | | //! - For even positions, input is the `previous` value before A. |
44 | | //! |
45 | | //! We iterate in a classic 1-D sliding window with a window of 3. |
46 | | //! For our sliding window approach, `A` is the 1st and `B` is either the 0th term or 2nd term |
47 | | //! depending on position we are writing.(see scalar code). |
48 | | //! |
49 | | //! For vector code see module sse for explanation. |
50 | | //! |
51 | | //! # Vertical bi-linear. |
52 | | //! Vertical up-sampling is a bit trickier. |
53 | | //! |
54 | | //! ```text |
55 | | //! +----+----+ |
56 | | //! | A1 | A2 | |
57 | | //! +----+----+ |
58 | | //! +----+----+ |
59 | | //! | p1 | p2 | |
60 | | //! +----+-+--+ |
61 | | //! +----+-+--+ |
62 | | //! | p3 | p4 | |
63 | | //! +----+-+--+ |
64 | | //! +----+----+ |
65 | | //! | B1 | B2 | |
66 | | //! +----+----+ |
67 | | //! ``` |
68 | | //! |
69 | | //! For `p1` |
70 | | //! - `A1` is given a weight of `3` and `B1` is given a weight of 1. |
71 | | //! |
72 | | //! For `p3` |
73 | | //! - `B1` is given a weight of `3` and `A1` is given a weight of 1 |
74 | | //! |
75 | | //! # Horizontal vertical downsampling/chroma quartering. |
76 | | //! |
77 | | //! Carry out a vertical filter in the first pass, then a horizontal filter in the second pass. |
78 | | use crate::components::UpSampler; |
79 | | |
80 | | mod scalar; |
81 | | |
82 | | // choose best possible implementation for this platform |
83 | 70 | pub fn choose_horizontal_samp_function(_use_unsafe: bool) -> UpSampler { |
84 | 70 | return scalar::upsample_horizontal; |
85 | 70 | } |
86 | | |
87 | 0 | pub fn choose_hv_samp_function(_use_unsafe: bool) -> UpSampler { |
88 | 0 | return scalar::upsample_hv; |
89 | 0 | } |
90 | | |
91 | 188 | pub fn choose_v_samp_function(_use_unsafe: bool) -> UpSampler { |
92 | 188 | return scalar::upsample_vertical; |
93 | 188 | } |
94 | | |
95 | | /// Upsample nothing |
96 | | |
97 | 0 | pub fn upsample_no_op( |
98 | 0 | _input: &[i16], _in_ref: &[i16], _in_near: &[i16], _scratch_space: &mut [i16], |
99 | 0 | _output: &mut [i16] |
100 | 0 | ) { |
101 | 0 | } |
102 | | |
103 | 875 | pub fn generic_sampler() -> UpSampler { |
104 | 875 | scalar::upsample_generic |
105 | 875 | } |