Trait EncoderToImpl

pub trait EncoderToImpl: Debug {
    // Required methods
    fn get_bitrate(&self) -> u32;
    fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError>;
    fn update_fmt_chunk(
        &self,
        fmt: &mut FmtChunk,
    ) -> Result<(), AudioWriteError>;
    fn begin_encoding(&mut self) -> Result<(), AudioWriteError>;
    fn finish(&mut self) -> Result<(), AudioWriteError>;
    fn write_samples__i8(
        &mut self,
        samples: &[i8],
    ) -> Result<(), AudioWriteError>;
    fn write_samples_i16(
        &mut self,
        samples: &[i16],
    ) -> Result<(), AudioWriteError>;
    fn write_samples_i24(
        &mut self,
        samples: &[i24],
    ) -> Result<(), AudioWriteError>;
    fn write_samples_i32(
        &mut self,
        samples: &[i32],
    ) -> Result<(), AudioWriteError>;
    fn write_samples_i64(
        &mut self,
        samples: &[i64],
    ) -> Result<(), AudioWriteError>;
    fn write_samples__u8(
        &mut self,
        samples: &[u8],
    ) -> Result<(), AudioWriteError>;
    fn write_samples_u16(
        &mut self,
        samples: &[u16],
    ) -> Result<(), AudioWriteError>;
    fn write_samples_u24(
        &mut self,
        samples: &[u24],
    ) -> Result<(), AudioWriteError>;
    fn write_samples_u32(
        &mut self,
        samples: &[u32],
    ) -> Result<(), AudioWriteError>;
    fn write_samples_u64(
        &mut self,
        samples: &[u64],
    ) -> Result<(), AudioWriteError>;
    fn write_samples_f32(
        &mut self,
        samples: &[f32],
    ) -> Result<(), AudioWriteError>;
    fn write_samples_f64(
        &mut self,
        samples: &[f64],
    ) -> Result<(), AudioWriteError>;

    // Provided methods
    fn write_frame__i8(&mut self, frame: &[i8]) -> Result<(), AudioWriteError> { ... }
    fn write_frame_i16(&mut self, frame: &[i16]) -> Result<(), AudioWriteError> { ... }
    fn write_frame_i24(&mut self, frame: &[i24]) -> Result<(), AudioWriteError> { ... }
    fn write_frame_i32(&mut self, frame: &[i32]) -> Result<(), AudioWriteError> { ... }
    fn write_frame_i64(&mut self, frame: &[i64]) -> Result<(), AudioWriteError> { ... }
    fn write_frame__u8(&mut self, frame: &[u8]) -> Result<(), AudioWriteError> { ... }
    fn write_frame_u16(&mut self, frame: &[u16]) -> Result<(), AudioWriteError> { ... }
    fn write_frame_u24(&mut self, frame: &[u24]) -> Result<(), AudioWriteError> { ... }
    fn write_frame_u32(&mut self, frame: &[u32]) -> Result<(), AudioWriteError> { ... }
    fn write_frame_u64(&mut self, frame: &[u64]) -> Result<(), AudioWriteError> { ... }
    fn write_frame_f32(&mut self, frame: &[f32]) -> Result<(), AudioWriteError> { ... }
    fn write_frame_f64(&mut self, frame: &[f64]) -> Result<(), AudioWriteError> { ... }
    fn write_frames__i8(
        &mut self,
        frames: &[Vec<i8>],
        channels: u16,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_frames_i16(
        &mut self,
        frames: &[Vec<i16>],
        channels: u16,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_frames_i24(
        &mut self,
        frames: &[Vec<i24>],
        channels: u16,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_frames_i32(
        &mut self,
        frames: &[Vec<i32>],
        channels: u16,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_frames_i64(
        &mut self,
        frames: &[Vec<i64>],
        channels: u16,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_frames__u8(
        &mut self,
        frames: &[Vec<u8>],
        channels: u16,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_frames_u16(
        &mut self,
        frames: &[Vec<u16>],
        channels: u16,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_frames_u24(
        &mut self,
        frames: &[Vec<u24>],
        channels: u16,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_frames_u32(
        &mut self,
        frames: &[Vec<u32>],
        channels: u16,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_frames_u64(
        &mut self,
        frames: &[Vec<u64>],
        channels: u16,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_frames_f32(
        &mut self,
        frames: &[Vec<f32>],
        channels: u16,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_frames_f64(
        &mut self,
        frames: &[Vec<f64>],
        channels: u16,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_sample__i8(&mut self, sample: i8) -> Result<(), AudioWriteError> { ... }
    fn write_sample_i16(&mut self, sample: i16) -> Result<(), AudioWriteError> { ... }
    fn write_sample_i24(&mut self, sample: i24) -> Result<(), AudioWriteError> { ... }
    fn write_sample_i32(&mut self, sample: i32) -> Result<(), AudioWriteError> { ... }
    fn write_sample_i64(&mut self, sample: i64) -> Result<(), AudioWriteError> { ... }
    fn write_sample__u8(&mut self, sample: u8) -> Result<(), AudioWriteError> { ... }
    fn write_sample_u16(&mut self, sample: u16) -> Result<(), AudioWriteError> { ... }
    fn write_sample_u24(&mut self, sample: u24) -> Result<(), AudioWriteError> { ... }
    fn write_sample_u32(&mut self, sample: u32) -> Result<(), AudioWriteError> { ... }
    fn write_sample_u64(&mut self, sample: u64) -> Result<(), AudioWriteError> { ... }
    fn write_sample_f32(&mut self, sample: f32) -> Result<(), AudioWriteError> { ... }
    fn write_sample_f64(&mut self, sample: f64) -> Result<(), AudioWriteError> { ... }
    fn write_mono_channel__i8(
        &mut self,
        monos: &[i8],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_mono_channel_i16(
        &mut self,
        monos: &[i16],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_mono_channel_i24(
        &mut self,
        monos: &[i24],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_mono_channel_i32(
        &mut self,
        monos: &[i32],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_mono_channel_i64(
        &mut self,
        monos: &[i64],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_mono_channel__u8(
        &mut self,
        monos: &[u8],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_mono_channel_u16(
        &mut self,
        monos: &[u16],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_mono_channel_u24(
        &mut self,
        monos: &[u24],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_mono_channel_u32(
        &mut self,
        monos: &[u32],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_mono_channel_u64(
        &mut self,
        monos: &[u64],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_mono_channel_f32(
        &mut self,
        monos: &[f32],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_mono_channel_f64(
        &mut self,
        monos: &[f64],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_sample__i8(
        &mut self,
        mono1: i8,
        mono2: i8,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_sample_i16(
        &mut self,
        mono1: i16,
        mono2: i16,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_sample_i24(
        &mut self,
        mono1: i24,
        mono2: i24,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_sample_i32(
        &mut self,
        mono1: i32,
        mono2: i32,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_sample_i64(
        &mut self,
        mono1: i64,
        mono2: i64,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_sample__u8(
        &mut self,
        mono1: u8,
        mono2: u8,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_sample_u16(
        &mut self,
        mono1: u16,
        mono2: u16,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_sample_u24(
        &mut self,
        mono1: u24,
        mono2: u24,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_sample_u32(
        &mut self,
        mono1: u32,
        mono2: u32,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_sample_u64(
        &mut self,
        mono1: u64,
        mono2: u64,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_sample_f32(
        &mut self,
        mono1: f32,
        mono2: f32,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_sample_f64(
        &mut self,
        mono1: f64,
        mono2: f64,
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_monos__i8(
        &mut self,
        mono1: &[i8],
        mono2: &[i8],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_monos_i16(
        &mut self,
        mono1: &[i16],
        mono2: &[i16],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_monos_i24(
        &mut self,
        mono1: &[i24],
        mono2: &[i24],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_monos_i32(
        &mut self,
        mono1: &[i32],
        mono2: &[i32],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_monos_i64(
        &mut self,
        mono1: &[i64],
        mono2: &[i64],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_monos__u8(
        &mut self,
        mono1: &[u8],
        mono2: &[u8],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_monos_u16(
        &mut self,
        mono1: &[u16],
        mono2: &[u16],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_monos_u24(
        &mut self,
        mono1: &[u24],
        mono2: &[u24],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_monos_u32(
        &mut self,
        mono1: &[u32],
        mono2: &[u32],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_monos_u64(
        &mut self,
        mono1: &[u64],
        mono2: &[u64],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_monos_f32(
        &mut self,
        mono1: &[f32],
        mono2: &[f32],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_dual_monos_f64(
        &mut self,
        mono1: &[f64],
        mono2: &[f64],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_monos__i8(
        &mut self,
        monos_array: &[Vec<i8>],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_monos_i16(
        &mut self,
        monos_array: &[Vec<i16>],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_monos_i24(
        &mut self,
        monos_array: &[Vec<i24>],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_monos_i32(
        &mut self,
        monos_array: &[Vec<i32>],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_monos_i64(
        &mut self,
        monos_array: &[Vec<i64>],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_monos__u8(
        &mut self,
        monos_array: &[Vec<u8>],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_monos_u16(
        &mut self,
        monos_array: &[Vec<u16>],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_monos_u24(
        &mut self,
        monos_array: &[Vec<u24>],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_monos_u32(
        &mut self,
        monos_array: &[Vec<u32>],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_monos_u64(
        &mut self,
        monos_array: &[Vec<u64>],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_monos_f32(
        &mut self,
        monos_array: &[Vec<f32>],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_monos_f64(
        &mut self,
        monos_array: &[Vec<f64>],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereo__i8(
        &mut self,
        stereo: (i8, i8),
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereo_i16(
        &mut self,
        stereo: (i16, i16),
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereo_i24(
        &mut self,
        stereo: (i24, i24),
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereo_i32(
        &mut self,
        stereo: (i32, i32),
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereo_i64(
        &mut self,
        stereo: (i64, i64),
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereo__u8(
        &mut self,
        stereo: (u8, u8),
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereo_u16(
        &mut self,
        stereo: (u16, u16),
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereo_u24(
        &mut self,
        stereo: (u24, u24),
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereo_u32(
        &mut self,
        stereo: (u32, u32),
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereo_u64(
        &mut self,
        stereo: (u64, u64),
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereo_f32(
        &mut self,
        stereo: (f32, f32),
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereo_f64(
        &mut self,
        stereo: (f64, f64),
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereos__i8(
        &mut self,
        stereos: &[(i8, i8)],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereos_i16(
        &mut self,
        stereos: &[(i16, i16)],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereos_i24(
        &mut self,
        stereos: &[(i24, i24)],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereos_i32(
        &mut self,
        stereos: &[(i32, i32)],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereos_i64(
        &mut self,
        stereos: &[(i64, i64)],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereos__u8(
        &mut self,
        stereos: &[(u8, u8)],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereos_u16(
        &mut self,
        stereos: &[(u16, u16)],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereos_u24(
        &mut self,
        stereos: &[(u24, u24)],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereos_u32(
        &mut self,
        stereos: &[(u32, u32)],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereos_u64(
        &mut self,
        stereos: &[(u64, u64)],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereos_f32(
        &mut self,
        stereos: &[(f32, f32)],
    ) -> Result<(), AudioWriteError> { ... }
    fn write_stereos_f64(
        &mut self,
        stereos: &[(f64, f64)],
    ) -> Result<(), AudioWriteError> { ... }
}

Required Methods

fn get_bitrate(&self) -> u32

fn new_fmt_chunk(&mut self) -> Result<FmtChunk, AudioWriteError>

fn update_fmt_chunk(&self, fmt: &mut FmtChunk) -> Result<(), AudioWriteError>

fn begin_encoding(&mut self) -> Result<(), AudioWriteError>

fn finish(&mut self) -> Result<(), AudioWriteError>

fn write_samples__i8(&mut self, samples: &[i8]) -> Result<(), AudioWriteError>

fn write_samples_i16(&mut self, samples: &[i16]) -> Result<(), AudioWriteError>

fn write_samples_i24(&mut self, samples: &[i24]) -> Result<(), AudioWriteError>

fn write_samples_i32(&mut self, samples: &[i32]) -> Result<(), AudioWriteError>

fn write_samples_i64(&mut self, samples: &[i64]) -> Result<(), AudioWriteError>

fn write_samples__u8(&mut self, samples: &[u8]) -> Result<(), AudioWriteError>

fn write_samples_u16(&mut self, samples: &[u16]) -> Result<(), AudioWriteError>

fn write_samples_u24(&mut self, samples: &[u24]) -> Result<(), AudioWriteError>

fn write_samples_u32(&mut self, samples: &[u32]) -> Result<(), AudioWriteError>

fn write_samples_u64(&mut self, samples: &[u64]) -> Result<(), AudioWriteError>

fn write_samples_f32(&mut self, samples: &[f32]) -> Result<(), AudioWriteError>

fn write_samples_f64(&mut self, samples: &[f64]) -> Result<(), AudioWriteError>

Provided Methods

fn write_frame__i8(&mut self, frame: &[i8]) -> Result<(), AudioWriteError>

fn write_frame_i16(&mut self, frame: &[i16]) -> Result<(), AudioWriteError>

fn write_frame_i24(&mut self, frame: &[i24]) -> Result<(), AudioWriteError>

fn write_frame_i32(&mut self, frame: &[i32]) -> Result<(), AudioWriteError>

fn write_frame_i64(&mut self, frame: &[i64]) -> Result<(), AudioWriteError>

fn write_frame__u8(&mut self, frame: &[u8]) -> Result<(), AudioWriteError>

fn write_frame_u16(&mut self, frame: &[u16]) -> Result<(), AudioWriteError>

fn write_frame_u24(&mut self, frame: &[u24]) -> Result<(), AudioWriteError>

fn write_frame_u32(&mut self, frame: &[u32]) -> Result<(), AudioWriteError>

fn write_frame_u64(&mut self, frame: &[u64]) -> Result<(), AudioWriteError>

fn write_frame_f32(&mut self, frame: &[f32]) -> Result<(), AudioWriteError>

fn write_frame_f64(&mut self, frame: &[f64]) -> Result<(), AudioWriteError>

fn write_frames__i8( &mut self, frames: &[Vec<i8>], channels: u16, ) -> Result<(), AudioWriteError>

fn write_frames_i16( &mut self, frames: &[Vec<i16>], channels: u16, ) -> Result<(), AudioWriteError>

fn write_frames_i24( &mut self, frames: &[Vec<i24>], channels: u16, ) -> Result<(), AudioWriteError>

fn write_frames_i32( &mut self, frames: &[Vec<i32>], channels: u16, ) -> Result<(), AudioWriteError>

fn write_frames_i64( &mut self, frames: &[Vec<i64>], channels: u16, ) -> Result<(), AudioWriteError>

fn write_frames__u8( &mut self, frames: &[Vec<u8>], channels: u16, ) -> Result<(), AudioWriteError>

fn write_frames_u16( &mut self, frames: &[Vec<u16>], channels: u16, ) -> Result<(), AudioWriteError>

fn write_frames_u24( &mut self, frames: &[Vec<u24>], channels: u16, ) -> Result<(), AudioWriteError>

fn write_frames_u32( &mut self, frames: &[Vec<u32>], channels: u16, ) -> Result<(), AudioWriteError>

fn write_frames_u64( &mut self, frames: &[Vec<u64>], channels: u16, ) -> Result<(), AudioWriteError>

fn write_frames_f32( &mut self, frames: &[Vec<f32>], channels: u16, ) -> Result<(), AudioWriteError>

fn write_frames_f64( &mut self, frames: &[Vec<f64>], channels: u16, ) -> Result<(), AudioWriteError>

fn write_sample__i8(&mut self, sample: i8) -> Result<(), AudioWriteError>

fn write_sample_i16(&mut self, sample: i16) -> Result<(), AudioWriteError>

fn write_sample_i24(&mut self, sample: i24) -> Result<(), AudioWriteError>

fn write_sample_i32(&mut self, sample: i32) -> Result<(), AudioWriteError>

fn write_sample_i64(&mut self, sample: i64) -> Result<(), AudioWriteError>

fn write_sample__u8(&mut self, sample: u8) -> Result<(), AudioWriteError>

fn write_sample_u16(&mut self, sample: u16) -> Result<(), AudioWriteError>

fn write_sample_u24(&mut self, sample: u24) -> Result<(), AudioWriteError>

fn write_sample_u32(&mut self, sample: u32) -> Result<(), AudioWriteError>

fn write_sample_u64(&mut self, sample: u64) -> Result<(), AudioWriteError>

fn write_sample_f32(&mut self, sample: f32) -> Result<(), AudioWriteError>

fn write_sample_f64(&mut self, sample: f64) -> Result<(), AudioWriteError>

fn write_mono_channel__i8( &mut self, monos: &[i8], ) -> Result<(), AudioWriteError>

fn write_mono_channel_i16( &mut self, monos: &[i16], ) -> Result<(), AudioWriteError>

fn write_mono_channel_i24( &mut self, monos: &[i24], ) -> Result<(), AudioWriteError>

fn write_mono_channel_i32( &mut self, monos: &[i32], ) -> Result<(), AudioWriteError>

fn write_mono_channel_i64( &mut self, monos: &[i64], ) -> Result<(), AudioWriteError>

fn write_mono_channel__u8( &mut self, monos: &[u8], ) -> Result<(), AudioWriteError>

fn write_mono_channel_u16( &mut self, monos: &[u16], ) -> Result<(), AudioWriteError>

fn write_mono_channel_u24( &mut self, monos: &[u24], ) -> Result<(), AudioWriteError>

fn write_mono_channel_u32( &mut self, monos: &[u32], ) -> Result<(), AudioWriteError>

fn write_mono_channel_u64( &mut self, monos: &[u64], ) -> Result<(), AudioWriteError>

fn write_mono_channel_f32( &mut self, monos: &[f32], ) -> Result<(), AudioWriteError>

fn write_mono_channel_f64( &mut self, monos: &[f64], ) -> Result<(), AudioWriteError>

fn write_dual_sample__i8( &mut self, mono1: i8, mono2: i8, ) -> Result<(), AudioWriteError>

fn write_dual_sample_i16( &mut self, mono1: i16, mono2: i16, ) -> Result<(), AudioWriteError>

fn write_dual_sample_i24( &mut self, mono1: i24, mono2: i24, ) -> Result<(), AudioWriteError>

fn write_dual_sample_i32( &mut self, mono1: i32, mono2: i32, ) -> Result<(), AudioWriteError>

fn write_dual_sample_i64( &mut self, mono1: i64, mono2: i64, ) -> Result<(), AudioWriteError>

fn write_dual_sample__u8( &mut self, mono1: u8, mono2: u8, ) -> Result<(), AudioWriteError>

fn write_dual_sample_u16( &mut self, mono1: u16, mono2: u16, ) -> Result<(), AudioWriteError>

fn write_dual_sample_u24( &mut self, mono1: u24, mono2: u24, ) -> Result<(), AudioWriteError>

fn write_dual_sample_u32( &mut self, mono1: u32, mono2: u32, ) -> Result<(), AudioWriteError>

fn write_dual_sample_u64( &mut self, mono1: u64, mono2: u64, ) -> Result<(), AudioWriteError>

fn write_dual_sample_f32( &mut self, mono1: f32, mono2: f32, ) -> Result<(), AudioWriteError>

fn write_dual_sample_f64( &mut self, mono1: f64, mono2: f64, ) -> Result<(), AudioWriteError>

fn write_dual_monos__i8( &mut self, mono1: &[i8], mono2: &[i8], ) -> Result<(), AudioWriteError>

fn write_dual_monos_i16( &mut self, mono1: &[i16], mono2: &[i16], ) -> Result<(), AudioWriteError>

fn write_dual_monos_i24( &mut self, mono1: &[i24], mono2: &[i24], ) -> Result<(), AudioWriteError>

fn write_dual_monos_i32( &mut self, mono1: &[i32], mono2: &[i32], ) -> Result<(), AudioWriteError>

fn write_dual_monos_i64( &mut self, mono1: &[i64], mono2: &[i64], ) -> Result<(), AudioWriteError>

fn write_dual_monos__u8( &mut self, mono1: &[u8], mono2: &[u8], ) -> Result<(), AudioWriteError>

fn write_dual_monos_u16( &mut self, mono1: &[u16], mono2: &[u16], ) -> Result<(), AudioWriteError>

fn write_dual_monos_u24( &mut self, mono1: &[u24], mono2: &[u24], ) -> Result<(), AudioWriteError>

fn write_dual_monos_u32( &mut self, mono1: &[u32], mono2: &[u32], ) -> Result<(), AudioWriteError>

fn write_dual_monos_u64( &mut self, mono1: &[u64], mono2: &[u64], ) -> Result<(), AudioWriteError>

fn write_dual_monos_f32( &mut self, mono1: &[f32], mono2: &[f32], ) -> Result<(), AudioWriteError>

fn write_dual_monos_f64( &mut self, mono1: &[f64], mono2: &[f64], ) -> Result<(), AudioWriteError>

fn write_monos__i8( &mut self, monos_array: &[Vec<i8>], ) -> Result<(), AudioWriteError>

fn write_monos_i16( &mut self, monos_array: &[Vec<i16>], ) -> Result<(), AudioWriteError>

fn write_monos_i24( &mut self, monos_array: &[Vec<i24>], ) -> Result<(), AudioWriteError>

fn write_monos_i32( &mut self, monos_array: &[Vec<i32>], ) -> Result<(), AudioWriteError>

fn write_monos_i64( &mut self, monos_array: &[Vec<i64>], ) -> Result<(), AudioWriteError>

fn write_monos__u8( &mut self, monos_array: &[Vec<u8>], ) -> Result<(), AudioWriteError>

fn write_monos_u16( &mut self, monos_array: &[Vec<u16>], ) -> Result<(), AudioWriteError>

fn write_monos_u24( &mut self, monos_array: &[Vec<u24>], ) -> Result<(), AudioWriteError>

fn write_monos_u32( &mut self, monos_array: &[Vec<u32>], ) -> Result<(), AudioWriteError>

fn write_monos_u64( &mut self, monos_array: &[Vec<u64>], ) -> Result<(), AudioWriteError>

fn write_monos_f32( &mut self, monos_array: &[Vec<f32>], ) -> Result<(), AudioWriteError>

fn write_monos_f64( &mut self, monos_array: &[Vec<f64>], ) -> Result<(), AudioWriteError>

fn write_stereo__i8(&mut self, stereo: (i8, i8)) -> Result<(), AudioWriteError>

fn write_stereo_i16( &mut self, stereo: (i16, i16), ) -> Result<(), AudioWriteError>

fn write_stereo_i24( &mut self, stereo: (i24, i24), ) -> Result<(), AudioWriteError>

fn write_stereo_i32( &mut self, stereo: (i32, i32), ) -> Result<(), AudioWriteError>

fn write_stereo_i64( &mut self, stereo: (i64, i64), ) -> Result<(), AudioWriteError>

fn write_stereo__u8(&mut self, stereo: (u8, u8)) -> Result<(), AudioWriteError>

fn write_stereo_u16( &mut self, stereo: (u16, u16), ) -> Result<(), AudioWriteError>

fn write_stereo_u24( &mut self, stereo: (u24, u24), ) -> Result<(), AudioWriteError>

fn write_stereo_u32( &mut self, stereo: (u32, u32), ) -> Result<(), AudioWriteError>

fn write_stereo_u64( &mut self, stereo: (u64, u64), ) -> Result<(), AudioWriteError>

fn write_stereo_f32( &mut self, stereo: (f32, f32), ) -> Result<(), AudioWriteError>

fn write_stereo_f64( &mut self, stereo: (f64, f64), ) -> Result<(), AudioWriteError>

fn write_stereos__i8( &mut self, stereos: &[(i8, i8)], ) -> Result<(), AudioWriteError>

fn write_stereos_i16( &mut self, stereos: &[(i16, i16)], ) -> Result<(), AudioWriteError>

fn write_stereos_i24( &mut self, stereos: &[(i24, i24)], ) -> Result<(), AudioWriteError>

fn write_stereos_i32( &mut self, stereos: &[(i32, i32)], ) -> Result<(), AudioWriteError>

fn write_stereos_i64( &mut self, stereos: &[(i64, i64)], ) -> Result<(), AudioWriteError>

fn write_stereos__u8( &mut self, stereos: &[(u8, u8)], ) -> Result<(), AudioWriteError>

fn write_stereos_u16( &mut self, stereos: &[(u16, u16)], ) -> Result<(), AudioWriteError>

fn write_stereos_u24( &mut self, stereos: &[(u24, u24)], ) -> Result<(), AudioWriteError>

fn write_stereos_u32( &mut self, stereos: &[(u32, u32)], ) -> Result<(), AudioWriteError>

fn write_stereos_u64( &mut self, stereos: &[(u64, u64)], ) -> Result<(), AudioWriteError>

fn write_stereos_f32( &mut self, stereos: &[(f32, f32)], ) -> Result<(), AudioWriteError>

fn write_stereos_f64( &mut self, stereos: &[(f64, f64)], ) -> Result<(), AudioWriteError>

Implementors

impl EncoderToImpl for DummyEncoder

impl<'a> EncoderToImpl for FlacEncoderWrap<'_>

impl<'a> EncoderToImpl for OpusEncoder<'_>

impl<'a> EncoderToImpl for PcmEncoder<'_>

impl<'a> EncoderToImpl for PcmXLawEncoderWrap<'_>

impl<'a, E> EncoderToImpl for AdpcmEncoderWrap<'_, E>

where E: AdpcmEncoder,

impl<'a, S> EncoderToImpl for Mp3Encoder<'_, S>

where S: SampleType,