xaac-rs 0.2.0

High-level Rust AAC/xHE-AAC encoder and decoder bindings built on libxaac
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use xaac_rs::{DecodeStatus, Decoder, DecoderConfig, Encoder, EncoderConfig, OutputFormat};

#[test]
fn decoder_initializes_with_default_config() {
    let decoder = Decoder::new(DecoderConfig::default()).expect("decoder should initialize");
    assert!(decoder.input_capacity() > 0);
}

#[test]
fn encodes_aac_lc_adts_frame() {
    let mut encoder = Encoder::new(EncoderConfig {
        output_format: OutputFormat::Adts,
        ..EncoderConfig::default()
    })
    .expect("encoder should initialize");

    let pcm = vec![0i16; encoder.input_frame_bytes() / 2];
    let encoded = encoder
        .encode_i16_interleaved(&pcm)
        .expect("frame should encode");

    assert!(!encoded.data.is_empty());
}

#[test]
fn encodes_partial_frame_with_zero_padding() {
    let mut encoder = Encoder::new(EncoderConfig {
        output_format: OutputFormat::Raw,
        ..EncoderConfig::default()
    })
    .expect("encoder should initialize");

    let partial = vec![0u8; encoder.input_frame_bytes() / 2];
    let encoded = encoder
        .encode_pcm_bytes_with_padding(&partial)
        .expect("partial frame should encode");

    assert_eq!(encoded.padded_input_bytes, partial.len());
    assert!(!encoder.audio_specific_config().is_empty());
    assert!(!encoded.packet.data.is_empty());
}

#[test]
fn decodes_adts_stream_in_small_chunks() {
    let mut encoder = Encoder::new(EncoderConfig {
        output_format: OutputFormat::Adts,
        ..EncoderConfig::default()
    })
    .expect("encoder should initialize");

    let mut bitstream = Vec::new();
    for frame_index in 0..4 {
        let pcm = vec![frame_index as i16; encoder.input_frame_bytes() / 2];
        let packet = encoder
            .encode_i16_interleaved(&pcm)
            .expect("frame should encode");
        bitstream.extend_from_slice(&packet.data);
    }

    let mut decoder = Decoder::new(DecoderConfig::default()).expect("decoder should initialize");
    let mut decoded_frames = 0usize;
    let mut offset = 0usize;
    while offset < bitstream.len() {
        let end = (offset + 37).min(bitstream.len());
        match decoder
            .decode_stream_chunk(&bitstream[offset..end])
            .expect("decode chunk should not fail")
        {
            DecodeStatus::Frame(frame) => {
                decoded_frames += 1;
                assert!(!frame.pcm.is_empty());
                assert!(frame.stream_info.channels >= 1);
            }
            DecodeStatus::NeedMoreInput(_) => {}
            DecodeStatus::EndOfStream => break,
        }
        offset = end;
    }

    loop {
        match decoder.finish().expect("finish should succeed") {
            DecodeStatus::Frame(frame) => {
                decoded_frames += 1;
                assert!(!frame.pcm.is_empty());
            }
            DecodeStatus::NeedMoreInput(_) => continue,
            DecodeStatus::EndOfStream => break,
        }
    }

    assert!(decoded_frames > 0);
    assert!(decoder.stream_info().is_some());
}