zoomvtools 1.1.1

Video motion vector analysis utilities in pure 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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

#[cfg(all(target_arch = "x86_64", feature = "avx2"))]
mod avx2;
mod rust;

#[cfg(test)]
mod tests;

use std::num::NonZeroUsize;

use crate::util::Pixel;

#[cfg(all(target_arch = "x86_64", feature = "avx2"))]
pub const MAX_REFS_SIZE: usize = 12;

pub type DegrainFn = unsafe fn(
    dest: *mut u8,
    dest_stride_bytes: NonZeroUsize,
    src: *const u8,
    src_stride_bytes: NonZeroUsize,
    refs: &[*const u8],
    refs_strides_bytes: &[NonZeroUsize],
    w_src: i32,
    w_refs: &[i32],
);

#[must_use]
#[inline]
pub fn select_degrain<T: Pixel, const RADIUS: usize>(
    width: NonZeroUsize,
    height: NonZeroUsize,
) -> DegrainFn {
    #[cfg(all(target_arch = "x86_64", feature = "avx2"))]
    if crate::util::has_avx2() {
        // PERF: 75-90% faster than scalar on test machine
        // depending on block size
        return select_degrain_avx2::<T, RADIUS>(width, height);
    }

    select_degrain_rust::<T, RADIUS>(width, height)
}

#[must_use]
fn select_degrain_rust<T: Pixel, const RADIUS: usize>(
    width: NonZeroUsize,
    height: NonZeroUsize,
) -> DegrainFn {
    match (width.get(), height.get()) {
        (2, 2) => rust::degrain::<T, RADIUS, 2, 2>,
        (2, 4) => rust::degrain::<T, RADIUS, 2, 4>,
        (4, 2) => rust::degrain::<T, RADIUS, 4, 2>,
        (4, 4) => rust::degrain::<T, RADIUS, 4, 4>,
        (4, 8) => rust::degrain::<T, RADIUS, 4, 8>,
        (8, 1) => rust::degrain::<T, RADIUS, 8, 1>,
        (8, 2) => rust::degrain::<T, RADIUS, 8, 2>,
        (8, 4) => rust::degrain::<T, RADIUS, 8, 4>,
        (8, 8) => rust::degrain::<T, RADIUS, 8, 8>,
        (8, 16) => rust::degrain::<T, RADIUS, 8, 16>,
        (16, 1) => rust::degrain::<T, RADIUS, 16, 1>,
        (16, 2) => rust::degrain::<T, RADIUS, 16, 2>,
        (16, 4) => rust::degrain::<T, RADIUS, 16, 4>,
        (16, 8) => rust::degrain::<T, RADIUS, 16, 8>,
        (16, 16) => rust::degrain::<T, RADIUS, 16, 16>,
        (16, 32) => rust::degrain::<T, RADIUS, 16, 32>,
        (32, 8) => rust::degrain::<T, RADIUS, 32, 8>,
        (32, 16) => rust::degrain::<T, RADIUS, 32, 16>,
        (32, 32) => rust::degrain::<T, RADIUS, 32, 32>,
        (32, 64) => rust::degrain::<T, RADIUS, 32, 64>,
        (64, 16) => rust::degrain::<T, RADIUS, 64, 16>,
        (64, 32) => rust::degrain::<T, RADIUS, 64, 32>,
        (64, 64) => rust::degrain::<T, RADIUS, 64, 64>,
        (64, 128) => rust::degrain::<T, RADIUS, 64, 128>,
        (128, 32) => rust::degrain::<T, RADIUS, 128, 32>,
        (128, 64) => rust::degrain::<T, RADIUS, 128, 64>,
        (128, 128) => rust::degrain::<T, RADIUS, 128, 128>,
        _ => unreachable!(),
    }
}

#[cfg(all(target_arch = "x86_64", feature = "avx2"))]
#[must_use]
pub(super) fn select_degrain_avx2<T: Pixel, const RADIUS: usize>(
    width: NonZeroUsize,
    height: NonZeroUsize,
) -> DegrainFn {
    match std::mem::size_of::<T>() {
        1 => select_degrain_avx2_u8::<RADIUS>(width, height),
        2 => select_degrain_avx2_u16::<RADIUS>(width, height),
        _ => unreachable!(),
    }
}

#[cfg(all(target_arch = "x86_64", feature = "avx2"))]
#[must_use]
fn select_degrain_avx2_u8<const RADIUS: usize>(
    width: NonZeroUsize,
    height: NonZeroUsize,
) -> DegrainFn {
    match (width.get(), height.get()) {
        (2, 2) => avx2::degrain_u8::<RADIUS, 2, 2>,
        (2, 4) => avx2::degrain_u8::<RADIUS, 2, 4>,
        (4, 2) => avx2::degrain_u8::<RADIUS, 4, 2>,
        (4, 4) => avx2::degrain_u8::<RADIUS, 4, 4>,
        (4, 8) => avx2::degrain_u8::<RADIUS, 4, 8>,
        (8, 1) => avx2::degrain_u8::<RADIUS, 8, 1>,
        (8, 2) => avx2::degrain_u8::<RADIUS, 8, 2>,
        (8, 4) => avx2::degrain_u8::<RADIUS, 8, 4>,
        (8, 8) => avx2::degrain_u8::<RADIUS, 8, 8>,
        (8, 16) => avx2::degrain_u8::<RADIUS, 8, 16>,
        (16, 1) => avx2::degrain_u8::<RADIUS, 16, 1>,
        (16, 2) => avx2::degrain_u8::<RADIUS, 16, 2>,
        (16, 4) => avx2::degrain_u8::<RADIUS, 16, 4>,
        (16, 8) => avx2::degrain_u8::<RADIUS, 16, 8>,
        (16, 16) => avx2::degrain_u8::<RADIUS, 16, 16>,
        (16, 32) => avx2::degrain_u8::<RADIUS, 16, 32>,
        (32, 8) => avx2::degrain_u8::<RADIUS, 32, 8>,
        (32, 16) => avx2::degrain_u8::<RADIUS, 32, 16>,
        (32, 32) => avx2::degrain_u8::<RADIUS, 32, 32>,
        (32, 64) => avx2::degrain_u8::<RADIUS, 32, 64>,
        (64, 16) => avx2::degrain_u8::<RADIUS, 64, 16>,
        (64, 32) => avx2::degrain_u8::<RADIUS, 64, 32>,
        (64, 64) => avx2::degrain_u8::<RADIUS, 64, 64>,
        (64, 128) => avx2::degrain_u8::<RADIUS, 64, 128>,
        (128, 32) => avx2::degrain_u8::<RADIUS, 128, 32>,
        (128, 64) => avx2::degrain_u8::<RADIUS, 128, 64>,
        (128, 128) => avx2::degrain_u8::<RADIUS, 128, 128>,
        _ => unreachable!(),
    }
}

#[cfg(all(target_arch = "x86_64", feature = "avx2"))]
#[must_use]
fn select_degrain_avx2_u16<const RADIUS: usize>(
    width: NonZeroUsize,
    height: NonZeroUsize,
) -> DegrainFn {
    match (width.get(), height.get()) {
        (2, 2) => avx2::degrain_u16::<RADIUS, 2, 2>,
        (2, 4) => avx2::degrain_u16::<RADIUS, 2, 4>,
        (4, 2) => avx2::degrain_u16::<RADIUS, 4, 2>,
        (4, 4) => avx2::degrain_u16::<RADIUS, 4, 4>,
        (4, 8) => avx2::degrain_u16::<RADIUS, 4, 8>,
        (8, 1) => avx2::degrain_u16::<RADIUS, 8, 1>,
        (8, 2) => avx2::degrain_u16::<RADIUS, 8, 2>,
        (8, 4) => avx2::degrain_u16::<RADIUS, 8, 4>,
        (8, 8) => avx2::degrain_u16::<RADIUS, 8, 8>,
        (8, 16) => avx2::degrain_u16::<RADIUS, 8, 16>,
        (16, 1) => avx2::degrain_u16::<RADIUS, 16, 1>,
        (16, 2) => avx2::degrain_u16::<RADIUS, 16, 2>,
        (16, 4) => avx2::degrain_u16::<RADIUS, 16, 4>,
        (16, 8) => avx2::degrain_u16::<RADIUS, 16, 8>,
        (16, 16) => avx2::degrain_u16::<RADIUS, 16, 16>,
        (16, 32) => avx2::degrain_u16::<RADIUS, 16, 32>,
        (32, 8) => avx2::degrain_u16::<RADIUS, 32, 8>,
        (32, 16) => avx2::degrain_u16::<RADIUS, 32, 16>,
        (32, 32) => avx2::degrain_u16::<RADIUS, 32, 32>,
        (32, 64) => avx2::degrain_u16::<RADIUS, 32, 64>,
        (64, 16) => avx2::degrain_u16::<RADIUS, 64, 16>,
        (64, 32) => avx2::degrain_u16::<RADIUS, 64, 32>,
        (64, 64) => avx2::degrain_u16::<RADIUS, 64, 64>,
        (64, 128) => avx2::degrain_u16::<RADIUS, 64, 128>,
        (128, 32) => avx2::degrain_u16::<RADIUS, 128, 32>,
        (128, 64) => avx2::degrain_u16::<RADIUS, 128, 64>,
        (128, 128) => avx2::degrain_u16::<RADIUS, 128, 128>,
        _ => unreachable!(),
    }
}