Struct DummyEncoder

pub struct DummyEncoder;

• The DummyEncoder is not for you to use, it allows me to implement Default for Encoder<'a>

Trait Implementations

impl Clone for DummyEncoder

fn clone(&self) -> DummyEncoder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DummyEncoder

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

Formats the value using the given formatter.

impl EncoderToImpl for DummyEncoder

• Default implementations: all functions are panic!

fn get_channels(&self) -> u16

fn get_max_channels(&self) -> u16

fn get_bitrate(&self) -> u32

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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>], ) -> Result<(), AudioWriteError>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Copy for DummyEncoder