Struct ApeInfo 

pub struct ApeInfo {

    pub version: u16,
    pub compression_level: u16,
    pub sample_rate: u32,
    pub channels: u16,
    pub bits_per_sample: u16,
    pub total_samples: u64,
    pub total_frames: u32,
    pub blocks_per_frame: u32,
    pub final_frame_blocks: u32,
    pub duration_ms: u64,
    pub block_align: u16,
    pub format_flags: u16,
    pub bytes_per_sample: u16,
    pub average_bitrate_kbps: u32,
    pub decompressed_bitrate_kbps: u32,
    pub file_size_bytes: u64,
    pub is_big_endian: bool,
    pub is_floating_point: bool,
    pub is_signed_8bit: bool,
    pub source_format: SourceFormat,
}

File metadata accessible without decoding.

Fields

version: u16

compression_level: u16

sample_rate: u32

channels: u16

bits_per_sample: u16

total_samples: u64

total_frames: u32

blocks_per_frame: u32

final_frame_blocks: u32

duration_ms: u64

block_align: u16

format_flags: u16

bytes_per_sample: u16

average_bitrate_kbps: u32

decompressed_bitrate_kbps: u32

file_size_bytes: u64

is_big_endian: bool

is_floating_point: bool

is_signed_8bit: bool

source_format: SourceFormat

Implementations

impl ApeInfo

pub fn frame_samples(&self, frame_idx: u32) -> u32

Number of samples (blocks) in a given frame.

pub fn generate_wav_header(&self) -> Vec<u8>

Generate a standard 44-byte RIFF/WAVE header for the decoded audio.

Use this when ApeDecoder::wav_header_data() returns None (the CREATE_WAV_HEADER flag was set, meaning the original header was not stored). Combine with decoded PCM to produce a valid WAV file:

let header = decoder.info().generate_wav_header();
let pcm = decoder.decode_all()?;
output.write_all(&header)?;
output.write_all(&pcm)?;

Examples found in repository

examples/decode_to_file.rs (line 47)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let (raw_mode, input, output) = if args.len() == 4 && args[1] == "--raw" {
        (true, &args[2], &args[3])
    } else if args.len() == 3 {
        (false, &args[1], &args[2])
    } else {
        eprintln!("Usage: decode_to_file [--raw] <input.ape> <output>");
        std::process::exit(1);
    };

    let file = File::open(input).expect("failed to open input file");
    let mut decoder =
        ape_decoder::ApeDecoder::new(BufReader::new(file)).expect("failed to parse APE");

    {
        let info = decoder.info();
        eprintln!(
            "{}Hz, {} ch, {}-bit, {} samples ({} ms)",
            info.sample_rate,
            info.channels,
            info.bits_per_sample,
            info.total_samples,
            info.duration_ms,
        );
    }

    let pcm = decoder.decode_all().expect("failed to decode");
    eprintln!("Decoded {} bytes of PCM", pcm.len());

    let mut out = File::create(output).expect("failed to create output file");

    if !raw_mode {
        // Write WAV header: prefer stored header from the APE file, fall back to generated
        let header = decoder
            .wav_header_data()
            .map(|h| h.to_vec())
            .unwrap_or_else(|| decoder.info().generate_wav_header());
        out.write_all(&header).expect("failed to write WAV header");
    }

    out.write_all(&pcm).expect("failed to write PCM data");
    eprintln!("Wrote {}", output);
}

Trait Implementations

impl Clone for ApeInfo

fn clone(&self) -> ApeInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ApeInfo

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

Formats the value using the given formatter.