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
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

mod block_functions;
#[cfg(all(target_arch = "x86_64", feature = "avx2"))]
mod cpu;
mod fps;
mod mask;
mod math;
#[cfg(test)]
mod tests;

use semisafe::slice::get as semisafe_get;
use semisafe::slice::get_mut as semisafe_get_mut;
use std::{
    fmt::Display,
    mem::{ManuallyDrop, MaybeUninit},
};

pub use crate::frame::PlaneSizeTuple;
pub use block_functions::*;

#[cfg(all(target_arch = "x86_64", feature = "avx2"))]
pub use cpu::*;
pub use fps::*;
pub use mask::*;
pub use math::*;
use num_traits::{AsPrimitive, PrimInt};

/// Represents a pixel that can be `u8` or `u16`
pub trait Pixel:
    Copy
    + Clone
    + Default
    + Send
    + Sync
    + PrimInt
    + Display
    + AsPrimitive<u16>
    + AsPrimitive<u32>
    + AsPrimitive<u64>
    + AsPrimitive<i32>
    + AsPrimitive<i64>
    + 'static
{
    #[must_use]
    #[allow(dead_code)]
    fn from_u16_or_max_value(value: u16) -> Self;

    #[must_use]
    fn from_u32_or_max_value(value: u32) -> Self;
}

impl<T> Pixel for T
where
    T: Copy
        + Clone
        + Default
        + Send
        + Sync
        + PrimInt
        + Display
        + AsPrimitive<u16>
        + AsPrimitive<u32>
        + AsPrimitive<u64>
        + AsPrimitive<i32>
        + AsPrimitive<i64>
        + 'static,
{
    #[inline(always)]
    fn from_u16_or_max_value(value: u16) -> Self {
        Self::from(value).unwrap_or_else(Self::max_value)
    }

    #[inline(always)]
    fn from_u32_or_max_value(value: u32) -> Self {
        Self::from(value).unwrap_or_else(Self::max_value)
    }
}

#[cfg_attr(feature = "tracing", tracing::instrument(skip_all))]
#[inline]
pub fn vs_bitblt<T: Pixel>(
    dest: &mut [T],
    dest_stride_pixels: std::num::NonZeroUsize,
    src: &[T],
    src_stride_pixels: std::num::NonZeroUsize,
    row_size: std::num::NonZeroUsize,
    height: std::num::NonZeroUsize,
) {
    let height = height.get();
    let row_size = row_size.get();
    let src_stride = src_stride_pixels.get();
    let dest_stride = dest_stride_pixels.get();

    if src_stride == dest_stride && src_stride == row_size {
        semisafe_get_mut(dest, ..row_size * height)
            .copy_from_slice(semisafe_get(src, ..row_size * height));
    } else {
        for i in 0..height {
            let src_start = i * src_stride;
            let dest_start = i * dest_stride;
            semisafe_get_mut(semisafe_get_mut(dest, dest_start..), ..row_size)
                .copy_from_slice(semisafe_get(semisafe_get(src, src_start..), ..row_size));
        }
    }
}

#[inline(always)]
#[must_use]
pub fn uninit_vec<T>(len: usize) -> Vec<MaybeUninit<T>> {
    let mut values = Vec::with_capacity(len);
    // SAFETY: `MaybeUninit<T>` may be left uninitialized until callers write every slot.
    unsafe { values.set_len(len) };
    values
}

#[inline(always)]
#[must_use]
/// # Safety
///
/// The caller must guarantee that every element in `values` has been initialized.
pub unsafe fn assume_init_vec<T>(values: Vec<MaybeUninit<T>>) -> Vec<T> {
    let mut values = ManuallyDrop::new(values);
    let ptr = values.as_mut_ptr().cast::<T>();
    let len = values.len();
    let cap = values.capacity();

    // SAFETY: Caller guarantees all elements have been initialized.
    unsafe { Vec::from_raw_parts(ptr, len, cap) }
}