zoomvtools 2.0.0

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

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

#[cfg(test)]
mod tests;

use std::{mem::size_of, num::NonZeroUsize};

use crate::util::Pixel;

/// Function pointer for luma_sum with block size baked in.
pub type LumaSumFn = unsafe fn(src: *const u8, src_pitch: NonZeroUsize) -> u64;

/// Selects the appropriate luma_sum function for the given block size.
///
/// # Panics
/// Panics if the block size is not supported.
#[must_use]
#[inline]
pub fn select_luma_sum<T: Pixel>(width: NonZeroUsize, height: NonZeroUsize) -> LumaSumFn {
    #[cfg(all(target_arch = "x86_64", feature = "simd"))]
    if cpudetect::x86_64::is_x86_64_v3_compatible() {
        match (size_of::<T>(), width.get(), height.get()) {
            // PERF: Equivalent to scalar on test machine
            (1, 4, 4) => return avx2::luma_sum_u8::<4, 4>,
            // PERF: 10-30% faster than scalar on test machine
            (1, 8, 4) => return avx2::luma_sum_u8::<8, 4>,
            (1, 8, 8) => return avx2::luma_sum_u8::<8, 8>,
            // PERF: 45% faster than scalar on test machine
            (1, 16, 2) => return avx2::luma_sum_u8::<16, 2>,
            (1, 16, 8) => return avx2::luma_sum_u8::<16, 8>,
            (1, 16, 16) => return avx2::luma_sum_u8::<16, 16>,
            // PERF: 50% faster than scalar on test machine
            (1, 32, 16) => return avx2::luma_sum_u8::<32, 16>,
            (1, 32, 32) => return avx2::luma_sum_u8::<32, 32>,
            // PERF: 35-60% faster than scalar on test machine
            (1, 64, 32) => return avx2::luma_sum_u8::<64, 32>,
            (1, 64, 64) => return avx2::luma_sum_u8::<64, 64>,
            // PERF: 85-100% faster than scalar on test machine
            (1, 128, 64) => return avx2::luma_sum_u8::<128, 64>,
            (1, 128, 128) => return avx2::luma_sum_u8::<128, 128>,
            // PERF: 0-15% faster than scalar on test machine
            (2, 4, 4) => return avx2::luma_sum_u16::<4, 4>,
            // PERF: Slightly faster than scalar on test machine
            (2, 8, 4) => return avx2::luma_sum_u16::<8, 4>,
            (2, 8, 8) => return avx2::luma_sum_u16::<8, 8>,
            // PERF: 60-90% faster than scalar on test machine
            (2, 16, 2) => return avx2::luma_sum_u16::<16, 2>,
            (2, 16, 8) => return avx2::luma_sum_u16::<16, 8>,
            (2, 16, 16) => return avx2::luma_sum_u16::<16, 16>,
            // PERF: 55-75% faster than scalar on test machine
            (2, 32, 16) => return avx2::luma_sum_u16::<32, 16>,
            (2, 32, 32) => return avx2::luma_sum_u16::<32, 32>,
            // PERF: 55% faster than scalar on test machine
            (2, 64, 32) => return avx2::luma_sum_u16::<64, 32>,
            (2, 64, 64) => return avx2::luma_sum_u16::<64, 64>,
            // PERF: 60-85% faster than scalar on test machine
            (2, 128, 64) => return avx2::luma_sum_u16::<128, 64>,
            (2, 128, 128) => return avx2::luma_sum_u16::<128, 128>,
            _ => {
                // fallthrough
            }
        };
    }

    match (size_of::<T>(), width.get(), height.get()) {
        (1, 4, 4) => rust::luma_sum_u8::<4, 4>,
        (1, 8, 4) => rust::luma_sum_u8::<8, 4>,
        (1, 8, 8) => rust::luma_sum_u8::<8, 8>,
        (1, 16, 2) => rust::luma_sum_u8::<16, 2>,
        (1, 16, 8) => rust::luma_sum_u8::<16, 8>,
        (1, 16, 16) => rust::luma_sum_u8::<16, 16>,
        (1, 32, 16) => rust::luma_sum_u8::<32, 16>,
        (1, 32, 32) => rust::luma_sum_u8::<32, 32>,
        (1, 64, 32) => rust::luma_sum_u8::<64, 32>,
        (1, 64, 64) => rust::luma_sum_u8::<64, 64>,
        (1, 128, 64) => rust::luma_sum_u8::<128, 64>,
        (1, 128, 128) => rust::luma_sum_u8::<128, 128>,
        (2, 4, 4) => rust::luma_sum_u16::<4, 4>,
        (2, 8, 4) => rust::luma_sum_u16::<8, 4>,
        (2, 8, 8) => rust::luma_sum_u16::<8, 8>,
        (2, 16, 2) => rust::luma_sum_u16::<16, 2>,
        (2, 16, 8) => rust::luma_sum_u16::<16, 8>,
        (2, 16, 16) => rust::luma_sum_u16::<16, 16>,
        (2, 32, 16) => rust::luma_sum_u16::<32, 16>,
        (2, 32, 32) => rust::luma_sum_u16::<32, 32>,
        (2, 64, 32) => rust::luma_sum_u16::<64, 32>,
        (2, 64, 64) => rust::luma_sum_u16::<64, 64>,
        (2, 128, 64) => rust::luma_sum_u16::<128, 64>,
        (2, 128, 128) => rust::luma_sum_u16::<128, 128>,
        _ => panic!("unsupported block size for luma_sum: {}x{}", width, height),
    }
}