eric/pmomusic
1
0
Fork 0
Code Issues 5 Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Add AAC support and update version

Browse Source 
This commit adds support for AAC audio decoding via the fdk-aac library, including:
- New AAC decoder module (ADTS streaming)
- Integration into the autodetection system
- Support for AAC in transcoding
- Updated version to 0.3.23
- Added necessary dependencies in Cargo.toml and Cargo.lock
- Added tests for AAC decoding
This commit is contained in:
Eric Coissac
2026-02-27 00:00:21 +01:00
parent 6fe2f6be95
commit 18b9194530
10 changed files with 288 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
Cargo.lock generated
View File

@@ -4,7 +4,7 @@ version = 4
[[package]]
name = "PMOMusic"
version = "0.3.22"
version = "0.3.23"
dependencies = [
"axum 0.8.7",
"console-subscriber",
@@ -1700,6 +1700,24 @@ dependencies = [
"simd-adler32",
]
[[package]]
name = "fdk-aac"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7bb67e142688083cb9afb63f2424203fc98c4e7afb494bf912b60b55513b177e"
dependencies = [
"fdk-aac-sys",
]
[[package]]
name = "fdk-aac-sys"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "24516d2611506d5cb1833555adc75f6baf9fe2706b9c13e6fc33a6b22c51ca83"
dependencies = [
"cc",
]
[[package]]
name = "find-msvc-tools"
version = "0.1.5"
@@ -4043,6 +4061,7 @@ version = "0.1.0"
dependencies = [
"bytes",
"claxon",
"fdk-aac",
"lewton",
"libc",
"libflac-sys",

2
PMOMusic/Cargo.toml
View File

@@ -1,6 +1,6 @@
[package]
name = "PMOMusic"
version = "0.3.22"
version = "0.3.23"
edition = "2024"
[dependencies]

1
pmoaudiocache/src/streaming.rs
View File

@@ -125,6 +125,7 @@ fn codec_to_string(codec: AudioCodec) -> String {
AudioCodec::OggOpus => "ogg_opus",
AudioCodec::Wav => "wav",
AudioCodec::Aiff => "aiff",
AudioCodec::Aac => "aac",
}
.to_string()
}

1
pmoflac/Cargo.toml
View File

@@ -19,6 +19,7 @@ libflac-sys = { version = "0.3.3", default-features = false, features = ["build-
lofty = "0.22"
minimp3 = "0.5"
opus = "0.3"
fdk-aac = "0.8"
pmometadata = { path = "../pmometadata" }
thiserror = { workspace = true }
tokio = { workspace = true, features = ["rt", "rt-multi-thread", "macros", "sync", "io-util", "fs"] }

177
pmoflac/src/aac.rs Normal file
View File

@@ -0,0 +1,177 @@
//! AAC Decoder Module (ADTS streaming)
//!
//! Provides asynchronous streaming AAC/ADTS decoding via libfdk-aac (statically linked).
//! Decodes AAC audio streams into PCM data (16-bit little-endian interleaved).
//!
//! Designed for live radio streams (e.g. Radio France icecast AAC 192kbps).
//! No seek required — pure linear streaming.
//!
//! ## Architecture
//!
//! ```text
//! AAC Input → [Ingest Task] → [Decode Task (blocking)] → [Writer Task] → PCM Output (AsyncRead)
//! ```
use fdk_aac::dec::{Decoder, DecoderError, Transport};
use tokio::{
io::AsyncRead,
sync::{mpsc, oneshot},
};
use crate::{
common::ChannelReader,
decoder_common::{
spawn_ingest_task, spawn_writer_task, DecodedStream, DecoderError as PmoDecoderError,
CHANNEL_CAPACITY, DUPLEX_BUFFER_SIZE,
},
pcm::StreamInfo,
stream::ManagedAsyncReader,
};
/// Errors that can occur while decoding AAC data.
pub type AacError = PmoDecoderError;
/// Async decoded AAC stream.
pub type AacDecodedStream = DecodedStream<AacError>;
/// Decodes an AAC/ADTS stream into PCM audio data (16-bit little-endian interleaved).
///
/// The input must be a raw ADTS stream (as produced by Radio France icecast).
/// No seek is required — the decoder processes frames linearly.
pub async fn decode_aac_stream<R>(reader: R) -> Result<AacDecodedStream, AacError>
where
R: AsyncRead + Unpin + Send + 'static,
{
let (ingest_tx, ingest_rx) = mpsc::channel(CHANNEL_CAPACITY);
spawn_ingest_task(reader, ingest_tx);
let (pcm_tx, pcm_rx) = mpsc::channel(CHANNEL_CAPACITY);
let (pcm_reader, pcm_writer) = tokio::io::duplex(DUPLEX_BUFFER_SIZE);
let (info_tx, info_rx) = oneshot::channel::<Result<StreamInfo, AacError>>();
let blocking_handle = tokio::task::spawn_blocking(move || -> Result<(), AacError> {
let mut channel_reader = ChannelReader::<AacError>::new(ingest_rx);
let mut decoder = Decoder::new(Transport::Adts);
let mut info_tx = Some(info_tx);
// Buffer de lecture — on lit des chunks et on les pousse au décodeur
let mut read_buf = vec![0u8; 8192];
// Buffer de sortie PCM — fdk-aac écrit des frames entières
let mut pcm_out = vec![0i16; 8192];
use std::io::Read;
loop {
// Lire des bytes depuis le stream ADTS
let n = match channel_reader.read(&mut read_buf) {
Ok(0) => break, // EOF
Ok(n) => n,
Err(e) => {
let err = AacError::Io {
kind: e.kind(),
message: e.to_string(),
};
if let Some(tx) = info_tx.take() {
let _ = tx.send(Err(err.clone()));
}
return Err(err);
}
};
// Pousser les bytes au décodeur fdk-aac
let filled = match decoder.fill(&read_buf[..n]) {
Ok(filled) => filled,
Err(e) => {
let err = AacError::Decode(format!("fdk-aac fill error: {:?}", e));
if let Some(tx) = info_tx.take() {
let _ = tx.send(Err(err.clone()));
}
return Err(err);
}
};
// Si fill n'a pas consommé tous les bytes, on les remet devant
// (fdk-aac peut ne pas consommer tout en une passe)
// Note: fdk-aac retourne le nombre de bytes non-consommés — on les ignore
// car le décodeur conserve son état interne entre appels.
let _ = filled;
// Décoder les frames disponibles
loop {
// Adapter la taille du buffer PCM si nécessaire
let stream_info = decoder.stream_info();
let frame_size = if stream_info.frameSize > 0 && stream_info.numChannels > 0 {
(stream_info.frameSize * stream_info.numChannels) as usize
} else {
2048 // taille par défaut avant la première frame
};
if pcm_out.len() < frame_size {
pcm_out.resize(frame_size, 0i16);
}
match decoder.decode_frame(&mut pcm_out) {
Ok(()) => {
let info_ref = decoder.stream_info();
// Envoyer les infos au premier décodage réussi
if let Some(tx) = info_tx.take() {
let info = StreamInfo {
sample_rate: info_ref.sampleRate as u32,
channels: info_ref.numChannels as u8,
bits_per_sample: 16,
total_samples: None,
max_block_size: 0,
min_block_size: 0,
};
if tx.send(Ok(info)).is_err() {
return Ok(());
}
}
// Convertir i16 → bytes little-endian
let samples = &pcm_out[..frame_size];
let mut bytes = Vec::with_capacity(samples.len() * 2);
for s in samples {
bytes.extend_from_slice(&s.to_le_bytes());
}
if pcm_tx.blocking_send(Ok(bytes)).is_err() {
return Ok(());
}
}
Err(DecoderError::NOT_ENOUGH_BITS) => {
// Pas assez de données — besoin de plus d'input
break;
}
Err(DecoderError::TRANSPORT_SYNC_ERROR) => {
// Erreur de sync ADTS transitoire — continuer
break;
}
Err(e) => {
let err = AacError::Decode(format!("fdk-aac decode error: {:?}", e));
if let Some(tx) = info_tx.take() {
let _ = tx.send(Err(err.clone()));
}
return Err(err);
}
}
}
}
if let Some(tx) = info_tx.take() {
let err = AacError::Decode("AAC stream contained no decodable frames".into());
let _ = tx.send(Err(err.clone()));
return Err(err);
}
Ok(())
});
let writer_handle = spawn_writer_task(pcm_rx, pcm_writer, blocking_handle, "aac-decode");
let info = info_rx.await.map_err(|_| AacError::ChannelClosed)??;
let reader = ManagedAsyncReader::new("aac-decode-writer", pcm_reader, writer_handle);
Ok(DecodedStream::new(info, reader))
}

38
pmoflac/src/autodetect.rs
View File

@@ -7,6 +7,7 @@ use std::{
use tokio::io::{AsyncRead, AsyncReadExt, ReadBuf};
use crate::{
aac::{decode_aac_stream, AacDecodedStream, AacError},
decode_aiff_stream, decode_flac_stream, decode_mp3_stream, decode_ogg_opus_stream,
decode_ogg_vorbis_stream, decode_wav_stream, pcm::StreamInfo, prefixed_reader::PrefixedReader,
AiffDecodedStream, AiffError, FlacDecodedStream, FlacError, Mp3DecodedStream, Mp3Error,
@@ -34,6 +35,8 @@ pub enum DecodeAudioError {
Wav(WavError),
#[error("AIFF decode error: {0}")]
Aiff(AiffError),
#[error("AAC decode error: {0}")]
Aac(AacError),
}
pub async fn decode_audio_stream<R>(reader: R) -> Result<DecodedAudioStream, DecodeAudioError>
@@ -94,6 +97,12 @@ where
.map_err(DecodeAudioError::Aiff)?;
DecodedAudioStream::Aiff(stream)
}
DetectedFormat::Aac => {
let stream = decode_aac_stream(prefixed)
.await
.map_err(DecodeAudioError::Aac)?;
DecodedAudioStream::Aac(stream)
}
};
Ok(stream)
@@ -106,6 +115,7 @@ pub enum DecodedAudioStream {
OggOpus(OggOpusDecodedStream),
Wav(WavDecodedStream),
Aiff(AiffDecodedStream),
Aac(AacDecodedStream),
}
impl DecodedAudioStream {
@@ -117,6 +127,7 @@ impl DecodedAudioStream {
DecodedAudioStream::OggOpus(inner) => inner.info(),
DecodedAudioStream::Wav(inner) => inner.info(),
DecodedAudioStream::Aiff(inner) => inner.info(),
DecodedAudioStream::Aac(inner) => inner.info(),
}
}
@@ -132,6 +143,7 @@ impl DecodedAudioStream {
}
DecodedAudioStream::Wav(inner) => inner.wait().await.map_err(DecodeAudioError::Wav),
DecodedAudioStream::Aiff(inner) => inner.wait().await.map_err(DecodeAudioError::Aiff),
DecodedAudioStream::Aac(inner) => inner.wait().await.map_err(DecodeAudioError::Aac),
}
}
@@ -161,6 +173,10 @@ impl DecodedAudioStream {
let (info, reader) = inner.into_parts();
(info, DecodedReader::Aiff(reader))
}
DecodedAudioStream::Aac(inner) => {
let (info, reader) = inner.into_parts();
(info, DecodedReader::Aac(reader))
}
}
}
}
@@ -178,6 +194,7 @@ impl AsyncRead for DecodedAudioStream {
DecodedAudioStream::OggOpus(inner) => Pin::new(inner).poll_read(cx, buf),
DecodedAudioStream::Wav(inner) => Pin::new(inner).poll_read(cx, buf),
DecodedAudioStream::Aiff(inner) => Pin::new(inner).poll_read(cx, buf),
DecodedAudioStream::Aac(inner) => Pin::new(inner).poll_read(cx, buf),
}
}
}
@@ -189,6 +206,7 @@ pub enum DecodedReader {
OggOpus(crate::stream::ManagedAsyncReader<OggOpusError>),
Wav(crate::stream::ManagedAsyncReader<WavError>),
Aiff(crate::stream::ManagedAsyncReader<AiffError>),
Aac(crate::stream::ManagedAsyncReader<AacError>),
}
impl DecodedReader {
@@ -200,6 +218,7 @@ impl DecodedReader {
DecodedReader::OggOpus(inner) => inner.wait().await.map_err(DecodeAudioError::Opus),
DecodedReader::Wav(inner) => inner.wait().await.map_err(DecodeAudioError::Wav),
DecodedReader::Aiff(inner) => inner.wait().await.map_err(DecodeAudioError::Aiff),
DecodedReader::Aac(inner) => inner.wait().await.map_err(DecodeAudioError::Aac),
}
}
}
@@ -217,6 +236,7 @@ impl AsyncRead for DecodedReader {
DecodedReader::OggOpus(inner) => Pin::new(inner).poll_read(cx, buf),
DecodedReader::Wav(inner) => Pin::new(inner).poll_read(cx, buf),
DecodedReader::Aiff(inner) => Pin::new(inner).poll_read(cx, buf),
DecodedReader::Aac(inner) => Pin::new(inner).poll_read(cx, buf),
}
}
}
@@ -242,12 +262,29 @@ fn detect_format(bytes: &[u8]) -> Option<DetectedFormat> {
if let Some(fmt) = detect_ogg(bytes) {
return Some(fmt);
}
// Tester AAC avant MP3 : ADTS (0xFF 0xF0/0xF8) est un sous-ensemble du syncword MP3
// (0xFF 0xEx), donc la détection MP3 absorberait les flux AAC si elle passait en premier.
if is_adts_aac(bytes) {
return Some(DetectedFormat::Aac);
}
if is_mp3(bytes) {
return Some(DetectedFormat::Mp3);
}
None
}
/// Détecte un flux AAC ADTS : syncword 0xFFF (12 bits) + layer = 00.
/// Structure du 2e octet : 1111 VLLL → V=version, L=layer(00 pour AAC), P=protection
/// MP3 a layer != 00 (01=III, 10=II, 11=I), AAC ADTS a layer == 00.
fn is_adts_aac(bytes: &[u8]) -> bool {
if bytes.len() < 2 {
return false;
}
// syncword = 0xFFF (12 bits) : byte0=0xFF, byte1[7:4]=0xF
// layer = byte1[2:1] == 0b00 (distingue AAC de MP3)
bytes[0] == 0xFF && (bytes[1] & 0xF6) == 0xF0
}
fn detect_ogg(bytes: &[u8]) -> Option<DetectedFormat> {
if bytes.len() < 27 || &bytes[..4] != b"OggS" {
return None;
@@ -294,4 +331,5 @@ enum DetectedFormat {
OggOpus,
Wav,
Aiff,
Aac,
}

2
pmoflac/src/lib.rs
View File

@@ -95,6 +95,7 @@
//! }
//! ```
pub mod aac;
pub mod aiff;
pub mod autodetect;
mod common;
@@ -114,6 +115,7 @@ pub mod transcode;
mod util;
pub mod wav;
pub use aac::{decode_aac_stream, AacDecodedStream, AacError};
pub use aiff::{decode_aiff_stream, AiffDecodedStream, AiffError};
pub use autodetect::{
decode_audio_stream, is_flac_magic_header, DecodeAudioError, DecodedAudioStream, DecodedReader,

4
pmoflac/src/transcode.rs
View File

@@ -31,6 +31,7 @@ pub enum AudioCodec {
OggOpus,
Wav,
Aiff,
Aac,
}
/// Options controlling how the transcoder operates.
@@ -195,6 +196,9 @@ where
DecodedAudioStream::Aiff(stream) => {
transcode_from_decoded(AudioCodec::Aiff, stream, options.encoder_options).await
}
DecodedAudioStream::Aac(stream) => {
transcode_from_decoded(AudioCodec::Aac, stream, options.encoder_options).await
}
}
}

43
pmoflac/tests/aac_decode.rs Normal file
View File

@@ -0,0 +1,43 @@
use pmoflac::decode_aac_stream;
use tokio::io::AsyncReadExt;
#[tokio::test]
async fn test_decode_adts_file() {
let file = tokio::fs::File::open("/tmp/test_adts.aac")
.await
.expect("test ADTS file not found — run: ffmpeg -i tests/SBRtestStereoHiBr.mp4 -vn -acodec copy -f adts /tmp/test_adts.aac");
let mut stream = decode_aac_stream(file)
.await
.expect("decode_aac_stream failed");
let info = stream.info().clone();
println!("StreamInfo: {} Hz, {} ch, {} bps", info.sample_rate, info.channels, info.bits_per_sample);
assert!(info.sample_rate > 0, "sample_rate should be > 0");
assert!(info.channels == 1 || info.channels == 2, "channels should be 1 or 2");
assert_eq!(info.bits_per_sample, 16);
let mut pcm = Vec::new();
stream.read_to_end(&mut pcm).await.expect("read_to_end failed");
println!("Decoded {} PCM bytes ({} samples)", pcm.len(), pcm.len() / 2);
assert!(pcm.len() > 0, "should have decoded some PCM data");
}
#[tokio::test]
async fn test_autodetect_adts() {
use pmoflac::decode_audio_stream;
let file = tokio::fs::File::open("/tmp/test_adts.aac")
.await
.expect("test ADTS file not found");
let stream = decode_audio_stream(file)
.await
.expect("decode_audio_stream failed");
let info = stream.info().clone();
println!("Autodetect: {} Hz, {} ch, {} bps", info.sample_rate, info.channels, info.bits_per_sample);
assert!(info.sample_rate > 0);
}

2
version.txt
View File

@@ -1 +1 @@
0.3.22
0.3.23