Struct ApeDecoder 

pub struct ApeDecoder<R: Read + Seek> { /* private fields */ }

A streaming APE decoder with seek support.

Implementations

impl<R: Read + Seek> ApeDecoder<R>

pub fn new(reader: R) -> ApeResult<Self>

Open an APE file and parse its header.

Examples found in repository

examples/decode.rs (line 12)

fn main() {
    let path = std::env::args().nth(1).expect("Usage: decode <file.ape>");
    let file = File::open(&path).expect("failed to open file");
    let mut decoder =
        ape_decoder::ApeDecoder::new(BufReader::new(file)).expect("failed to parse APE");

    let info = decoder.info();
    println!(
        "{}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");
    println!("Decoded {} bytes of PCM", pcm.len());
}

examples/decode_to_file.rs (line 23)

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);
}

pub fn info(&self) -> &ApeInfo

Get file metadata.

Examples found in repository

examples/decode.rs (line 14)

fn main() {
    let path = std::env::args().nth(1).expect("Usage: decode <file.ape>");
    let file = File::open(&path).expect("failed to open file");
    let mut decoder =
        ape_decoder::ApeDecoder::new(BufReader::new(file)).expect("failed to parse APE");

    let info = decoder.info();
    println!(
        "{}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");
    println!("Decoded {} bytes of PCM", pcm.len());
}

examples/decode_to_file.rs (line 26)

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);
}

pub fn total_frames(&self) -> u32

Total number of frames in the file.

pub fn decode_frame(&mut self, frame_idx: u32) -> ApeResult<Vec<u8>>

Decode a single frame by index, returning raw PCM bytes.

pub fn decode_all(&mut self) -> ApeResult<Vec<u8>>

Decode all frames, returning all PCM bytes.

Examples found in repository

examples/decode.rs (line 20)

fn main() {
    let path = std::env::args().nth(1).expect("Usage: decode <file.ape>");
    let file = File::open(&path).expect("failed to open file");
    let mut decoder =
        ape_decoder::ApeDecoder::new(BufReader::new(file)).expect("failed to parse APE");

    let info = decoder.info();
    println!(
        "{}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");
    println!("Decoded {} bytes of PCM", pcm.len());
}

examples/decode_to_file.rs (line 37)

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);
}

pub fn decode_all_with<F: FnMut(f64) -> bool>( &mut self, on_progress: F, ) -> ApeResult<Vec<u8>>

Decode all frames with a progress closure.

The closure receives a progress fraction (0.0 to 1.0) after each frame. Return true to continue, false to cancel decoding.

pub fn decode_all_parallel(&mut self, thread_count: usize) -> ApeResult<Vec<u8>>

Decode all frames using multiple threads for parallel decoding.

Frame data is read sequentially (IO is serial), but frame decoding runs in parallel across thread_count threads. Falls back to single-threaded if thread_count <= 1.

Output is byte-identical to decode_all().

pub fn decode_range( &mut self, start_sample: u64, end_sample: u64, ) -> ApeResult<Vec<u8>>

Decode a sample range, returning only the PCM bytes within start_sample..end_sample (exclusive end).

This is more efficient than decode_all() for extracting a portion of a file, as it only decodes the frames that overlap the requested range.

pub fn seek(&mut self, sample: u64) -> ApeResult<SeekResult>

Seek to a specific sample position. Returns a SeekResult with the frame index, number of samples to skip within that frame, and the exact sample position.

pub fn decode_from(&mut self, sample: u64) -> ApeResult<Vec<u8>>

Seek to a sample position and return PCM from that point to the end of the containing frame.

pub fn wav_header_data(&self) -> Option<&[u8]>

Get the original WAV header data stored in the APE file. Returns None if the CREATE_WAV_HEADER flag is set (header not stored).

Examples found in repository

examples/decode_to_file.rs (line 45)

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);
}

pub fn wav_terminating_bytes(&self) -> u32

Get the number of terminating data bytes from the original container.

pub fn read_tag(&mut self) -> ApeResult<Option<ApeTag>>

Read and parse APE tags from the file (APEv2 format). Returns None if no tag is present.

pub fn read_id3v2_tag(&mut self) -> ApeResult<Option<Id3v2Tag>>

Read and parse an ID3v2 tag from the beginning of the file. Returns None if no ID3v2 header is present.

pub fn stored_md5(&self) -> &[u8; 16]

Get the stored MD5 hash from the APE descriptor.

pub fn verify_md5(&mut self) -> ApeResult<bool>

Quick verify: compute MD5 over raw file sections and compare against the stored hash in the APE descriptor. Returns Ok(true) if the hash matches, Ok(false) if it doesn’t, or Err on I/O failure.

This validates file integrity without decompressing the audio. Requires version >= 3980.

pub fn frames(&mut self) -> FrameIterator<'_, R>

Returns an iterator over decoded frames.

pub fn file_info(&self) -> &ApeFileInfo

Access the parsed file info (header, seek table, derived values).

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

Get the byte alignment remainder for a given frame. This value is needed when decoding raw frame bytes externally.

pub fn read_frame_data(&mut self, frame_idx: u32) -> ApeResult<Vec<u8>>

Read the compressed data for a given frame from the source. The returned bytes include alignment prefix and padding as needed by the APE bitreader. Use seek_remainder() to get the bit offset.