devela::_dep::symphonia::core::conv::dither

Trait MaybeDither

pub trait MaybeDither<T>: Sample
where T: Sample,
{ const DITHERABLE: bool; // Required method fn maybe_dither<D>(self, dither: &mut D) -> Self where D: Dither<Self, T>; }
Available on crate feature dep_symphonia only.
Expand description

MaybeDither conditionally applies a dither to a sample depending on the source and destination sample types.

Required Associated Constants§

Required Methods§

fn maybe_dither<D>(self, dither: &mut D) -> Self
where D: Dither<Self, T>,

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

§

impl MaybeDither<f32> for f32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f32
where D: Dither<f32, f32>,

§

impl MaybeDither<f32> for f64

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f64
where D: Dither<f64, f32>,

§

impl MaybeDither<f32> for i8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i8
where D: Dither<i8, f32>,

§

impl MaybeDither<f32> for i16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i16
where D: Dither<i16, f32>,

§

impl MaybeDither<f32> for i32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i32
where D: Dither<i32, f32>,

§

impl MaybeDither<f32> for u8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u8
where D: Dither<u8, f32>,

§

impl MaybeDither<f32> for u16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u16
where D: Dither<u16, f32>,

§

impl MaybeDither<f32> for u32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u32
where D: Dither<u32, f32>,

§

impl MaybeDither<f64> for f32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f32
where D: Dither<f32, f64>,

§

impl MaybeDither<f64> for f64

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f64
where D: Dither<f64, f64>,

§

impl MaybeDither<f64> for i8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i8
where D: Dither<i8, f64>,

§

impl MaybeDither<f64> for i16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i16
where D: Dither<i16, f64>,

§

impl MaybeDither<f64> for i32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i32
where D: Dither<i32, f64>,

§

impl MaybeDither<f64> for u8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u8
where D: Dither<u8, f64>,

§

impl MaybeDither<f64> for u16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u16
where D: Dither<u16, f64>,

§

impl MaybeDither<f64> for u32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u32
where D: Dither<u32, f64>,

§

impl MaybeDither<i8> for f32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f32
where D: Dither<f32, i8>,

§

impl MaybeDither<i8> for f64

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f64
where D: Dither<f64, i8>,

§

impl MaybeDither<i8> for i8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i8
where D: Dither<i8, i8>,

§

impl MaybeDither<i8> for i16

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> i16
where D: Dither<i16, i8>,

§

impl MaybeDither<i8> for i32

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> i32
where D: Dither<i32, i8>,

§

impl MaybeDither<i8> for u8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u8
where D: Dither<u8, i8>,

§

impl MaybeDither<i8> for u16

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> u16
where D: Dither<u16, i8>,

§

impl MaybeDither<i8> for u32

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> u32
where D: Dither<u32, i8>,

§

impl MaybeDither<i16> for f32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f32
where D: Dither<f32, i16>,

§

impl MaybeDither<i16> for f64

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f64
where D: Dither<f64, i16>,

§

impl MaybeDither<i16> for i8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i8
where D: Dither<i8, i16>,

§

impl MaybeDither<i16> for i16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i16
where D: Dither<i16, i16>,

§

impl MaybeDither<i16> for i32

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> i32
where D: Dither<i32, i16>,

§

impl MaybeDither<i16> for u8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u8
where D: Dither<u8, i16>,

§

impl MaybeDither<i16> for u16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u16
where D: Dither<u16, i16>,

§

impl MaybeDither<i16> for u32

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> u32
where D: Dither<u32, i16>,

§

impl MaybeDither<i32> for f32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f32
where D: Dither<f32, i32>,

§

impl MaybeDither<i32> for f64

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f64
where D: Dither<f64, i32>,

§

impl MaybeDither<i32> for i8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i8
where D: Dither<i8, i32>,

§

impl MaybeDither<i32> for i16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i16
where D: Dither<i16, i32>,

§

impl MaybeDither<i32> for i32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i32
where D: Dither<i32, i32>,

§

impl MaybeDither<i32> for u8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u8
where D: Dither<u8, i32>,

§

impl MaybeDither<i32> for u16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u16
where D: Dither<u16, i32>,

§

impl MaybeDither<i32> for u32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u32
where D: Dither<u32, i32>,

§

impl MaybeDither<u8> for f32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f32
where D: Dither<f32, u8>,

§

impl MaybeDither<u8> for f64

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f64
where D: Dither<f64, u8>,

§

impl MaybeDither<u8> for i8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i8
where D: Dither<i8, u8>,

§

impl MaybeDither<u8> for i16

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> i16
where D: Dither<i16, u8>,

§

impl MaybeDither<u8> for i32

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> i32
where D: Dither<i32, u8>,

§

impl MaybeDither<u8> for u8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u8
where D: Dither<u8, u8>,

§

impl MaybeDither<u8> for u16

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> u16
where D: Dither<u16, u8>,

§

impl MaybeDither<u8> for u32

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> u32
where D: Dither<u32, u8>,

§

impl MaybeDither<u16> for f32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f32
where D: Dither<f32, u16>,

§

impl MaybeDither<u16> for f64

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f64
where D: Dither<f64, u16>,

§

impl MaybeDither<u16> for i8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i8
where D: Dither<i8, u16>,

§

impl MaybeDither<u16> for i16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i16
where D: Dither<i16, u16>,

§

impl MaybeDither<u16> for i32

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> i32
where D: Dither<i32, u16>,

§

impl MaybeDither<u16> for u8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u8
where D: Dither<u8, u16>,

§

impl MaybeDither<u16> for u16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u16
where D: Dither<u16, u16>,

§

impl MaybeDither<u16> for u32

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> u32
where D: Dither<u32, u16>,

§

impl MaybeDither<u32> for f32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f32
where D: Dither<f32, u32>,

§

impl MaybeDither<u32> for f64

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f64
where D: Dither<f64, u32>,

§

impl MaybeDither<u32> for i8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i8
where D: Dither<i8, u32>,

§

impl MaybeDither<u32> for i16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i16
where D: Dither<i16, u32>,

§

impl MaybeDither<u32> for i32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i32
where D: Dither<i32, u32>,

§

impl MaybeDither<u32> for u8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u8
where D: Dither<u8, u32>,

§

impl MaybeDither<u32> for u16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u16
where D: Dither<u16, u32>,

§

impl MaybeDither<u32> for u32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u32
where D: Dither<u32, u32>,

§

impl MaybeDither<i24> for f32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f32
where D: Dither<f32, i24>,

§

impl MaybeDither<i24> for f64

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f64
where D: Dither<f64, i24>,

§

impl MaybeDither<i24> for i8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i8
where D: Dither<i8, i24>,

§

impl MaybeDither<i24> for i16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i16
where D: Dither<i16, i24>,

§

impl MaybeDither<i24> for i32

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> i32
where D: Dither<i32, i24>,

§

impl MaybeDither<i24> for u8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u8
where D: Dither<u8, i24>,

§

impl MaybeDither<i24> for u16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u16
where D: Dither<u16, i24>,

§

impl MaybeDither<i24> for u32

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> u32
where D: Dither<u32, i24>,

§

impl MaybeDither<u24> for f32

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f32
where D: Dither<f32, u24>,

§

impl MaybeDither<u24> for f64

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> f64
where D: Dither<f64, u24>,

§

impl MaybeDither<u24> for i8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i8
where D: Dither<i8, u24>,

§

impl MaybeDither<u24> for i16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> i16
where D: Dither<i16, u24>,

§

impl MaybeDither<u24> for i32

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> i32
where D: Dither<i32, u24>,

§

impl MaybeDither<u24> for u8

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u8
where D: Dither<u8, u24>,

§

impl MaybeDither<u24> for u16

§

const DITHERABLE: bool = false

§

fn maybe_dither<D>(self, _: &mut D) -> u16
where D: Dither<u16, u24>,

§

impl MaybeDither<u24> for u32

§

const DITHERABLE: bool = true

§

fn maybe_dither<D>(self, dither: &mut D) -> u32
where D: Dither<u32, u24>,

Implementors§

§

impl MaybeDither<f32> for i24

§

const DITHERABLE: bool = false

§

impl MaybeDither<f32> for u24

§

const DITHERABLE: bool = false

§

impl MaybeDither<f64> for i24

§

const DITHERABLE: bool = false

§

impl MaybeDither<f64> for u24

§

const DITHERABLE: bool = false

§

impl MaybeDither<i8> for i24

§

const DITHERABLE: bool = true

§

impl MaybeDither<i8> for u24

§

const DITHERABLE: bool = true

§

impl MaybeDither<i16> for i24

§

const DITHERABLE: bool = true

§

impl MaybeDither<i16> for u24

§

const DITHERABLE: bool = true

§

impl MaybeDither<i32> for i24

§

const DITHERABLE: bool = false

§

impl MaybeDither<i32> for u24

§

const DITHERABLE: bool = false

§

impl MaybeDither<u8> for i24

§

const DITHERABLE: bool = true

§

impl MaybeDither<u8> for u24

§

const DITHERABLE: bool = true

§

impl MaybeDither<u16> for i24

§

const DITHERABLE: bool = true

§

impl MaybeDither<u16> for u24

§

const DITHERABLE: bool = true

§

impl MaybeDither<u32> for i24

§

const DITHERABLE: bool = false

§

impl MaybeDither<u32> for u24

§

const DITHERABLE: bool = false

§

impl MaybeDither<i24> for i24

§

const DITHERABLE: bool = false

§

impl MaybeDither<i24> for u24

§

const DITHERABLE: bool = false

§

impl MaybeDither<u24> for i24

§

const DITHERABLE: bool = false

§

impl MaybeDither<u24> for u24

§

const DITHERABLE: bool = false