Struct AVFloatDSPContext

#[repr(C)]
pub struct AVFloatDSPContext {
    pub vector_fmul: Option<unsafe extern "C" fn(dst: *mut f32, src0: *const f32, src1: *const f32, len: c_int)>,
    pub vector_fmac_scalar: Option<unsafe extern "C" fn(dst: *mut f32, src: *const f32, mul: f32, len: c_int)>,
    pub vector_dmac_scalar: Option<unsafe extern "C" fn(dst: *mut f64, src: *const f64, mul: f64, len: c_int)>,
    pub vector_fmul_scalar: Option<unsafe extern "C" fn(dst: *mut f32, src: *const f32, mul: f32, len: c_int)>,
    pub vector_dmul_scalar: Option<unsafe extern "C" fn(dst: *mut f64, src: *const f64, mul: f64, len: c_int)>,
    pub vector_fmul_window: Option<unsafe extern "C" fn(dst: *mut f32, src0: *const f32, src1: *const f32, win: *const f32, len: c_int)>,
    pub vector_fmul_add: Option<unsafe extern "C" fn(dst: *mut f32, src0: *const f32, src1: *const f32, src2: *const f32, len: c_int)>,
    pub vector_fmul_reverse: Option<unsafe extern "C" fn(dst: *mut f32, src0: *const f32, src1: *const f32, len: c_int)>,
    pub butterflies_float: Option<unsafe extern "C" fn(v1: *mut f32, v2: *mut f32, len: c_int)>,
    pub scalarproduct_float: Option<unsafe extern "C" fn(v1: *const f32, v2: *const f32, len: c_int) -> f32>,
    pub vector_dmul: Option<unsafe extern "C" fn(dst: *mut f64, src0: *const f64, src1: *const f64, len: c_int)>,
}

Fields

vector_fmul: Option<unsafe extern "C" fn(dst: *mut f32, src0: *const f32, src1: *const f32, len: c_int)>

Calculate the entry wise product of two vectors of floats and store the result in a vector of floats.

@param dst output vector constraints: 32-byte aligned @param src0 first input vector constraints: 32-byte aligned @param src1 second input vector constraints: 32-byte aligned @param len number of elements in the input constraints: multiple of 16

vector_fmac_scalar: Option<unsafe extern "C" fn(dst: *mut f32, src: *const f32, mul: f32, len: c_int)>

Multiply a vector of floats by a scalar float and add to destination vector. Source and destination vectors must overlap exactly or not at all.

@param dst result vector constraints: 32-byte aligned @param src input vector constraints: 32-byte aligned @param mul scalar value @param len length of vector constraints: multiple of 16

vector_dmac_scalar: Option<unsafe extern "C" fn(dst: *mut f64, src: *const f64, mul: f64, len: c_int)>

Multiply a vector of doubles by a scalar double and add to destination vector. Source and destination vectors must overlap exactly or not at all.

@param dst result vector constraints: 32-byte aligned @param src input vector constraints: 32-byte aligned @param mul scalar value @param len length of vector constraints: multiple of 16

vector_fmul_scalar: Option<unsafe extern "C" fn(dst: *mut f32, src: *const f32, mul: f32, len: c_int)>

Multiply a vector of floats by a scalar float. Source and destination vectors must overlap exactly or not at all.

@param dst result vector constraints: 16-byte aligned @param src input vector constraints: 16-byte aligned @param mul scalar value @param len length of vector constraints: multiple of 4

vector_dmul_scalar: Option<unsafe extern "C" fn(dst: *mut f64, src: *const f64, mul: f64, len: c_int)>

Multiply a vector of double by a scalar double. Source and destination vectors must overlap exactly or not at all.

@param dst result vector constraints: 32-byte aligned @param src input vector constraints: 32-byte aligned @param mul scalar value @param len length of vector constraints: multiple of 8

vector_fmul_window: Option<unsafe extern "C" fn(dst: *mut f32, src0: *const f32, src1: *const f32, win: *const f32, len: c_int)>

Overlap/add with window function. Used primarily by MDCT-based audio codecs. Source and destination vectors must overlap exactly or not at all.

@param dst result vector constraints: 16-byte aligned @param src0 first source vector constraints: 16-byte aligned @param src1 second source vector constraints: 16-byte aligned @param win half-window vector constraints: 16-byte aligned @param len length of vector constraints: multiple of 4

vector_fmul_add: Option<unsafe extern "C" fn(dst: *mut f32, src0: *const f32, src1: *const f32, src2: *const f32, len: c_int)>

Calculate the entry wise product of two vectors of floats, add a third vector of floats and store the result in a vector of floats.

@param dst output vector constraints: 32-byte aligned @param src0 first input vector constraints: 32-byte aligned @param src1 second input vector constraints: 32-byte aligned @param src2 third input vector constraints: 32-byte aligned @param len number of elements in the input constraints: multiple of 16

vector_fmul_reverse: Option<unsafe extern "C" fn(dst: *mut f32, src0: *const f32, src1: *const f32, len: c_int)>

Calculate the entry wise product of two vectors of floats, and store the result in a vector of floats. The second vector of floats is iterated over in reverse order.

@param dst output vector constraints: 32-byte aligned @param src0 first input vector constraints: 32-byte aligned @param src1 second input vector constraints: 32-byte aligned @param len number of elements in the input constraints: multiple of 16

butterflies_float: Option<unsafe extern "C" fn(v1: *mut f32, v2: *mut f32, len: c_int)>

Calculate the sum and difference of two vectors of floats.

@param v1 first input vector, sum output, 16-byte aligned @param v2 second input vector, difference output, 16-byte aligned @param len length of vectors, multiple of 4

scalarproduct_float: Option<unsafe extern "C" fn(v1: *const f32, v2: *const f32, len: c_int) -> f32>

Calculate the scalar product of two vectors of floats.

@param v1 first vector, 16-byte aligned @param v2 second vector, 16-byte aligned @param len length of vectors, multiple of 4

@return sum of elementwise products

vector_dmul: Option<unsafe extern "C" fn(dst: *mut f64, src0: *const f64, src1: *const f64, len: c_int)>

Calculate the entry wise product of two vectors of doubles and store the result in a vector of doubles.

@param dst output vector constraints: 32-byte aligned @param src0 first input vector constraints: 32-byte aligned @param src1 second input vector constraints: 32-byte aligned @param len number of elements in the input constraints: multiple of 16

Trait Implementations

impl Clone for AVFloatDSPContext

fn clone(&self) -> AVFloatDSPContext

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AVFloatDSPContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Copy for AVFloatDSPContext