zoomvtools 1.1.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

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

#[cfg(test)]
mod tests;

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

use crate::util::Pixel;

/// Function pointer for SATD (Sum of Absolute Transformed Differences) with block size baked in.
pub type SatdFn = unsafe fn(
    src: *const u8,
    src_pitch: NonZeroUsize,
    ref_: *const u8,
    ref_pitch: NonZeroUsize,
) -> u64;

/// Selects the appropriate SATD function for the given block size.
///
/// # Panics
/// Panics if the block size is not supported.
#[must_use]
#[inline]
pub fn select_satd<T: Pixel>(width: NonZeroUsize, height: NonZeroUsize) -> SatdFn {
    #[cfg(all(target_arch = "x86_64", feature = "avx2"))]
    if crate::util::has_avx2() {
        match (size_of::<T>(), width.get(), height.get()) {
            // PERF: 30% faster than scalar on test machine
            (1, 4, 4) => return avx2::get_satd_u8::<4, 4>,
            // PERF: 25% faster than scalar on test machine
            (1, 8, 4) => return avx2::get_satd_u8::<8, 4>,
            (1, 8, 8) => return avx2::get_satd_u8::<8, 8>,
            // PERF: 60% faster than scalar on test machine
            (1, 16, 8) => return avx2::get_satd_u8::<16, 8>,
            (1, 16, 16) => return avx2::get_satd_u8::<16, 16>,
            // PERF: 60% faster than scalar on test machine
            (1, 32, 16) => return avx2::get_satd_u8::<32, 16>,
            (1, 32, 32) => return avx2::get_satd_u8::<32, 32>,
            // PERF: 60% faster than scalar on test machine
            (1, 64, 32) => return avx2::get_satd_u8::<64, 32>,
            (1, 64, 64) => return avx2::get_satd_u8::<64, 64>,
            // PERF: 60% faster than scalar on test machine
            (1, 128, 64) => return avx2::get_satd_u8::<128, 64>,
            (1, 128, 128) => return avx2::get_satd_u8::<128, 128>,
            // PERF: 40% faster than scalar on test machine
            (2, 4, 4) => return avx2::get_satd_u16::<4, 4>,
            // PERF: 45% faster than scalar on test machine
            (2, 8, 4) => return avx2::get_satd_u16::<8, 4>,
            (2, 8, 8) => return avx2::get_satd_u16::<8, 8>,
            // PERF: 50% faster than scalar on test machine
            (2, 16, 8) => return avx2::get_satd_u16::<16, 8>,
            (2, 16, 16) => return avx2::get_satd_u16::<16, 16>,
            // PERF: 50% faster than scalar on test machine
            (2, 32, 16) => return avx2::get_satd_u16::<32, 16>,
            (2, 32, 32) => return avx2::get_satd_u16::<32, 32>,
            // PERF: 50% faster than scalar on test machine
            (2, 64, 32) => return avx2::get_satd_u16::<64, 32>,
            (2, 64, 64) => return avx2::get_satd_u16::<64, 64>,
            // PERF: 50% faster than scalar on test machine
            (2, 128, 64) => return avx2::get_satd_u16::<128, 64>,
            (2, 128, 128) => return avx2::get_satd_u16::<128, 128>,
            _ => {}
        };
    }

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