Trait symphonia_core::conv::dither::MaybeDither

pub trait MaybeDither<T: Sample>: Sample {
    const DITHERABLE: bool;

    // Required method
    fn maybe_dither<D: Dither<Self, T>>(self, dither: &mut D) -> Self;
}

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

Required Associated Constants

const DITHERABLE: bool

Required Methods

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

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl MaybeDither<f32> for f32

const DITHERABLE: bool = false

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

impl MaybeDither<f32> for f64

const DITHERABLE: bool = false

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

impl MaybeDither<f32> for i8

const DITHERABLE: bool = false

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

impl MaybeDither<f32> for i16

const DITHERABLE: bool = false

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

impl MaybeDither<f32> for i32

const DITHERABLE: bool = false

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

impl MaybeDither<f32> for u8

const DITHERABLE: bool = false

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

impl MaybeDither<f32> for u16

const DITHERABLE: bool = false

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

impl MaybeDither<f32> for u32

const DITHERABLE: bool = false

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

impl MaybeDither<f64> for f32

const DITHERABLE: bool = false

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

impl MaybeDither<f64> for f64

const DITHERABLE: bool = false

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

impl MaybeDither<f64> for i8

const DITHERABLE: bool = false

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

impl MaybeDither<f64> for i16

const DITHERABLE: bool = false

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

impl MaybeDither<f64> for i32

const DITHERABLE: bool = false

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

impl MaybeDither<f64> for u8

const DITHERABLE: bool = false

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

impl MaybeDither<f64> for u16

const DITHERABLE: bool = false

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

impl MaybeDither<f64> for u32

const DITHERABLE: bool = false

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

impl MaybeDither<i8> for f32

const DITHERABLE: bool = false

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

impl MaybeDither<i8> for f64

const DITHERABLE: bool = false

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

impl MaybeDither<i8> for i8

const DITHERABLE: bool = false

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

impl MaybeDither<i8> for i16

const DITHERABLE: bool = true

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

impl MaybeDither<i8> for i32

const DITHERABLE: bool = true

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

impl MaybeDither<i8> for u8

const DITHERABLE: bool = false

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

impl MaybeDither<i8> for u16

const DITHERABLE: bool = true

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

impl MaybeDither<i8> for u32

const DITHERABLE: bool = true

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

impl MaybeDither<i16> for f32

const DITHERABLE: bool = false

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

impl MaybeDither<i16> for f64

const DITHERABLE: bool = false

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

impl MaybeDither<i16> for i8

const DITHERABLE: bool = false

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

impl MaybeDither<i16> for i16

const DITHERABLE: bool = false

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

impl MaybeDither<i16> for i32

const DITHERABLE: bool = true

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

impl MaybeDither<i16> for u8

const DITHERABLE: bool = false

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

impl MaybeDither<i16> for u16

const DITHERABLE: bool = false

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

impl MaybeDither<i16> for u32

const DITHERABLE: bool = true

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

impl MaybeDither<i32> for f32

const DITHERABLE: bool = false

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

impl MaybeDither<i32> for f64

const DITHERABLE: bool = false

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

impl MaybeDither<i32> for i8

const DITHERABLE: bool = false

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

impl MaybeDither<i32> for i16

const DITHERABLE: bool = false

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

impl MaybeDither<i32> for i32

const DITHERABLE: bool = false

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

impl MaybeDither<i32> for u8

const DITHERABLE: bool = false

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

impl MaybeDither<i32> for u16

const DITHERABLE: bool = false

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

impl MaybeDither<i32> for u32

const DITHERABLE: bool = false

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

impl MaybeDither<u8> for f32

const DITHERABLE: bool = false

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

impl MaybeDither<u8> for f64

const DITHERABLE: bool = false

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

impl MaybeDither<u8> for i8

const DITHERABLE: bool = false

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

impl MaybeDither<u8> for i16

const DITHERABLE: bool = true

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

impl MaybeDither<u8> for i32

const DITHERABLE: bool = true

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

impl MaybeDither<u8> for u8

const DITHERABLE: bool = false

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

impl MaybeDither<u8> for u16

const DITHERABLE: bool = true

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

impl MaybeDither<u8> for u32

const DITHERABLE: bool = true

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

impl MaybeDither<u16> for f32

const DITHERABLE: bool = false

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

impl MaybeDither<u16> for f64

const DITHERABLE: bool = false

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

impl MaybeDither<u16> for i8

const DITHERABLE: bool = false

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

impl MaybeDither<u16> for i16

const DITHERABLE: bool = false

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

impl MaybeDither<u16> for i32

const DITHERABLE: bool = true

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

impl MaybeDither<u16> for u8

const DITHERABLE: bool = false

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

impl MaybeDither<u16> for u16

const DITHERABLE: bool = false

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

impl MaybeDither<u16> for u32

const DITHERABLE: bool = true

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

impl MaybeDither<u32> for f32

const DITHERABLE: bool = false

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

impl MaybeDither<u32> for f64

const DITHERABLE: bool = false

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

impl MaybeDither<u32> for i8

const DITHERABLE: bool = false

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

impl MaybeDither<u32> for i16

const DITHERABLE: bool = false

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

impl MaybeDither<u32> for i32

const DITHERABLE: bool = false

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

impl MaybeDither<u32> for u8

const DITHERABLE: bool = false

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

impl MaybeDither<u32> for u16

const DITHERABLE: bool = false

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

impl MaybeDither<u32> for u32

const DITHERABLE: bool = false

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

impl MaybeDither<i24> for f32

const DITHERABLE: bool = false

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

impl MaybeDither<i24> for f64

const DITHERABLE: bool = false

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

impl MaybeDither<i24> for i8

const DITHERABLE: bool = false

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

impl MaybeDither<i24> for i16

const DITHERABLE: bool = false

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

impl MaybeDither<i24> for i32

const DITHERABLE: bool = true

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

impl MaybeDither<i24> for u8

const DITHERABLE: bool = false

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

impl MaybeDither<i24> for u16

const DITHERABLE: bool = false

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

impl MaybeDither<i24> for u32

const DITHERABLE: bool = true

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

impl MaybeDither<u24> for f32

const DITHERABLE: bool = false

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

impl MaybeDither<u24> for f64

const DITHERABLE: bool = false

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

impl MaybeDither<u24> for i8

const DITHERABLE: bool = false

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

impl MaybeDither<u24> for i16

const DITHERABLE: bool = false

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

impl MaybeDither<u24> for i32

const DITHERABLE: bool = true

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

impl MaybeDither<u24> for u8

const DITHERABLE: bool = false

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

impl MaybeDither<u24> for u16

const DITHERABLE: bool = false

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

impl MaybeDither<u24> for u32

const DITHERABLE: bool = true

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

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