Struct Encoder 

pub struct Encoder { /* private fields */ }

Implementations

impl Encoder

pub fn new(config: EncoderConfig) -> Result<Self>

Examples found in repository

examples/convert_wav_to_aac.rs (lines 22-32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);
    let input = args.next().ok_or_else(usage)?;
    let output = args.next().ok_or_else(usage)?;
    let bitrate = match args.next() {
        Some(value) => value
            .parse::<u32>()
            .map_err(|_| "bitrate must be an integer number of bits per second")?,
        None => 128_000,
    };

    let wav_bytes = fs::read(&input)?;
    let wav = WavFile::parse(&wav_bytes)?;

    let mut encoder = Encoder::new(EncoderConfig {
        profile: Profile::AacLc,
        sample_rate: wav.sample_rate,
        native_sample_rate: Some(wav.sample_rate),
        channels: wav.channels,
        channel_mask: wav.channel_mask.unwrap_or(0),
        bitrate,
        pcm_word_size: wav.bits_per_sample,
        output_format: OutputFormat::Adts,
        ..EncoderConfig::default()
    })?;

    let mut out = fs::File::create(Path::new(&output))?;
    let frame_bytes = encoder.input_frame_bytes();
    let mut offset = 0usize;
    while offset + frame_bytes <= wav.pcm_data.len() {
        let packet = encoder.encode_pcm_bytes(&wav.pcm_data[offset..offset + frame_bytes])?;
        out.write_all(&packet.data)?;
        offset += frame_bytes;
    }

    if offset < wav.pcm_data.len() {
        let frame = encoder.encode_pcm_bytes_with_padding(&wav.pcm_data[offset..])?;
        out.write_all(&frame.packet.data)?;
    }

    eprintln!(
        "encoded {} Hz, {} channels, {}-bit PCM to ADTS AAC at {} bps",
        wav.sample_rate, wav.channels, wav.bits_per_sample, bitrate
    );

    Ok(())
}

pub fn config(&self) -> &EncoderConfig

pub fn version(&self) -> &VersionInfo

pub fn input_frame_bytes(&self) -> usize

Examples found in repository

examples/convert_wav_to_aac.rs (line 35)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);
    let input = args.next().ok_or_else(usage)?;
    let output = args.next().ok_or_else(usage)?;
    let bitrate = match args.next() {
        Some(value) => value
            .parse::<u32>()
            .map_err(|_| "bitrate must be an integer number of bits per second")?,
        None => 128_000,
    };

    let wav_bytes = fs::read(&input)?;
    let wav = WavFile::parse(&wav_bytes)?;

    let mut encoder = Encoder::new(EncoderConfig {
        profile: Profile::AacLc,
        sample_rate: wav.sample_rate,
        native_sample_rate: Some(wav.sample_rate),
        channels: wav.channels,
        channel_mask: wav.channel_mask.unwrap_or(0),
        bitrate,
        pcm_word_size: wav.bits_per_sample,
        output_format: OutputFormat::Adts,
        ..EncoderConfig::default()
    })?;

    let mut out = fs::File::create(Path::new(&output))?;
    let frame_bytes = encoder.input_frame_bytes();
    let mut offset = 0usize;
    while offset + frame_bytes <= wav.pcm_data.len() {
        let packet = encoder.encode_pcm_bytes(&wav.pcm_data[offset..offset + frame_bytes])?;
        out.write_all(&packet.data)?;
        offset += frame_bytes;
    }

    if offset < wav.pcm_data.len() {
        let frame = encoder.encode_pcm_bytes_with_padding(&wav.pcm_data[offset..])?;
        out.write_all(&frame.packet.data)?;
    }

    eprintln!(
        "encoded {} Hz, {} channels, {}-bit PCM to ADTS AAC at {} bps",
        wav.sample_rate, wav.channels, wav.bits_per_sample, bitrate
    );

    Ok(())
}

pub fn input_samples_per_channel(&self) -> usize

pub fn expected_frame_count(&self) -> usize

pub fn audio_specific_config(&self) -> &[u8]

pub fn encode_pcm_bytes(&mut self, pcm: &[u8]) -> Result<EncodedPacket>

Examples found in repository

examples/convert_wav_to_aac.rs (line 38)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);
    let input = args.next().ok_or_else(usage)?;
    let output = args.next().ok_or_else(usage)?;
    let bitrate = match args.next() {
        Some(value) => value
            .parse::<u32>()
            .map_err(|_| "bitrate must be an integer number of bits per second")?,
        None => 128_000,
    };

    let wav_bytes = fs::read(&input)?;
    let wav = WavFile::parse(&wav_bytes)?;

    let mut encoder = Encoder::new(EncoderConfig {
        profile: Profile::AacLc,
        sample_rate: wav.sample_rate,
        native_sample_rate: Some(wav.sample_rate),
        channels: wav.channels,
        channel_mask: wav.channel_mask.unwrap_or(0),
        bitrate,
        pcm_word_size: wav.bits_per_sample,
        output_format: OutputFormat::Adts,
        ..EncoderConfig::default()
    })?;

    let mut out = fs::File::create(Path::new(&output))?;
    let frame_bytes = encoder.input_frame_bytes();
    let mut offset = 0usize;
    while offset + frame_bytes <= wav.pcm_data.len() {
        let packet = encoder.encode_pcm_bytes(&wav.pcm_data[offset..offset + frame_bytes])?;
        out.write_all(&packet.data)?;
        offset += frame_bytes;
    }

    if offset < wav.pcm_data.len() {
        let frame = encoder.encode_pcm_bytes_with_padding(&wav.pcm_data[offset..])?;
        out.write_all(&frame.packet.data)?;
    }

    eprintln!(
        "encoded {} Hz, {} channels, {}-bit PCM to ADTS AAC at {} bps",
        wav.sample_rate, wav.channels, wav.bits_per_sample, bitrate
    );

    Ok(())
}

pub fn encode_pcm_bytes_with_padding( &mut self, pcm: &[u8], ) -> Result<EncodedFrame>

Examples found in repository

examples/convert_wav_to_aac.rs (line 44)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);
    let input = args.next().ok_or_else(usage)?;
    let output = args.next().ok_or_else(usage)?;
    let bitrate = match args.next() {
        Some(value) => value
            .parse::<u32>()
            .map_err(|_| "bitrate must be an integer number of bits per second")?,
        None => 128_000,
    };

    let wav_bytes = fs::read(&input)?;
    let wav = WavFile::parse(&wav_bytes)?;

    let mut encoder = Encoder::new(EncoderConfig {
        profile: Profile::AacLc,
        sample_rate: wav.sample_rate,
        native_sample_rate: Some(wav.sample_rate),
        channels: wav.channels,
        channel_mask: wav.channel_mask.unwrap_or(0),
        bitrate,
        pcm_word_size: wav.bits_per_sample,
        output_format: OutputFormat::Adts,
        ..EncoderConfig::default()
    })?;

    let mut out = fs::File::create(Path::new(&output))?;
    let frame_bytes = encoder.input_frame_bytes();
    let mut offset = 0usize;
    while offset + frame_bytes <= wav.pcm_data.len() {
        let packet = encoder.encode_pcm_bytes(&wav.pcm_data[offset..offset + frame_bytes])?;
        out.write_all(&packet.data)?;
        offset += frame_bytes;
    }

    if offset < wav.pcm_data.len() {
        let frame = encoder.encode_pcm_bytes_with_padding(&wav.pcm_data[offset..])?;
        out.write_all(&frame.packet.data)?;
    }

    eprintln!(
        "encoded {} Hz, {} channels, {}-bit PCM to ADTS AAC at {} bps",
        wav.sample_rate, wav.channels, wav.bits_per_sample, bitrate
    );

    Ok(())
}

pub fn encode_i16_interleaved(&mut self, pcm: &[i16]) -> Result<EncodedPacket>

pub fn encode_i24_interleaved( &mut self, pcm: &[[u8; 3]], ) -> Result<EncodedPacket>

pub fn encode_i32_interleaved(&mut self, pcm: &[i32]) -> Result<EncodedPacket>

Trait Implementations

impl Debug for Encoder

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

Formats the value using the given formatter.

impl Drop for Encoder

fn drop(&mut self)

Executes the destructor for this type.