Crate mp3lame_encoder 

High level wrapper over mp3lame-sys

Example

use mp3lame_encoder::{Builder, Id3Tag, DualPcm, FlushNoGap};

let id3tag = Id3Tag {
    title: b"My title",
    artist: &[],
    album: b"My album",
    album_art: &[],
    year: b"Current year",
    comment: b"Just my comment",
};

//Methods prefixed with `with_*` return Self for convenience
let mut mp3_encoder = Builder::new().expect("Create LAME builder")
    .with_num_channels(2).expect("set channels")
    .with_sample_rate(44_100).expect("set sample rate")
    .with_brate(mp3lame_encoder::Bitrate::Kbps192).expect("set brate")
    .with_quality(mp3lame_encoder::Quality::Best).expect("set quality")
    .with_vbr_mode(mp3lame_encoder::VbrMode::Mtrh).expect("set VBR")
    .with_vbr_quality(mp3lame_encoder::Quality::Best).expect("set VBR quality")
    .with_to_write_vbr_tag(true).expect("set to write VBR tag")
    .with_id3_tag(id3tag).expect("set tags")
    .build().expect("To initialize LAME encoder");

//use actual PCM data
let input = DualPcm {
    left: &[0u16, 1024],
    right: &[0u16, 1024],
};

let mut mp3_out_buffer = Vec::new();
mp3_out_buffer.reserve(mp3lame_encoder::max_required_buffer_size(input.left.len()));
let encoded_size = mp3_encoder.encode(input, mp3_out_buffer.spare_capacity_mut()).expect("To encode");
unsafe {
    mp3_out_buffer.set_len(mp3_out_buffer.len().wrapping_add(encoded_size));
}

let encoded_size = mp3_encoder.flush::<FlushNoGap>(mp3_out_buffer.spare_capacity_mut()).expect("to flush");
unsafe {
    mp3_out_buffer.set_len(mp3_out_buffer.len().wrapping_add(encoded_size));
}
//At this point your mp3_out_buffer should have full MP3 data, ready to be written on file system or whatever

if mp3_encoder.lame_tag_size() > 0 {
   let id3v2_tag_boundary = mp3_encoder.id3v2_tag_size();
   assert_eq!(id3v2_tag_boundary, 158);
   let mut lame_tag = [core::mem::MaybeUninit::uninit(); 1024];
   assert!(lame_tag.len() >= mp3_encoder.lame_tag_size(), "Increase buffer size");
   let lame_tag_size = mp3_encoder.lame_tag_encode(&mut lame_tag).expect("to write lame tag");
   assert_eq!(mp3_encoder.lame_tag_size(), lame_tag_size.get());

   //If you need VBR tag then you need to write mp3 file in following order
   //- id3v2 tag
   //- VBR tag
   //- actual mp3 content
   let chunks_to_write = [
       &mp3_out_buffer[..id3v2_tag_boundary],
       unsafe {
           core::slice::from_raw_parts(lame_tag.as_ptr() as *const u8, lame_tag_size.get())
       },
       &mp3_out_buffer[id3v2_tag_boundary..],
   ];
} else {
   let chunks_to_write = [
       &mp3_out_buffer[..]
   ];
}

Re-exports

pub use Bitrate as Birtate;

pub use mp3lame_sys as ffi;

Structs

Builder

Builder of C LAME encoder.

DualPcm

PCM data represented by two channels.

Encoder

LAME Encoder.

FlushGap

Performs flush, padding gaps with 0

FlushNoGap

Performs flush, padding it with ancillary data

Id3Tag

ID3 tag as raw bytes.

InterleavedPcm

PCM data in interleaved form

MonoPcm

PCM data with only 1 channel

Enums

Bitrate

Enumeration of valid values for set_brate

BuildError

Encoder builder errors

EncodeError

Encoder errors

Id3TagError

ID3 setter errors

Mode

Possible modes for encoder

Quality

Possible quality parameter. From best(0) to worst(9)

VbrMode

Possible VBR types

Constants

MAX_ALBUM_ART_SIZE

Maximum size of album art

Traits

EncoderFlush

Flush method.

EncoderInput

Type of PCM input for encoder

Functions

encoder

Creates default encoder with 192kbps bitrate and best possible quality.

max_required_buffer_size

Calculates maximum required size for specified number of samples.