- Drop `Path`/``State``` from unused Axum imports in config.rs and registry
- Mark `_position_sec` field as `#[allow(dead_code)]`` in PositionUpdateRequest and PlayerStateReport
- Remove unused macro rules (`add_action_arg!`, `add_action!``, `` add_var!)``
- Delete unused PlayerReport struct and related handler code
- Introduce `Streamtype` enum (Continuous vs Finite) to distinguish radio streams from finite tracks
- Enrich `TrackBoundary` sync marker with stream type for proper pause behavior per mode (silence vs backpressure)
- Update all sources and sinks to pass `StreamType` when creating track boundaries
- Radio Paradise, HTTP source → Continuous (infinite)
- Improve UPnP control architecture: pause sends silence for radio, blocks pipeline via backpressure for tracks
- Prepare groundwork for multi-client DSP architecture with shared source and per-DSP pipelines
- Ajout d'un BaseUrl layer dans pmoserver pour gérer les URLs absolues (LAN/WAN)
- Renommage de `covers_absolute_url_for` → ` covers_relative_route`, stocker les routes relatives
- Mise à jour des appels UPnP vers `covers_absolute_url_for_upnp` (fallback PMO_SERVER_URL)
- Correction des tâches de fond pour stocker les routes, pas l'URL complète
- Suppression du feature gate `simd` inutilisé dans pmoaudio/src/lib.rs
- Suppress dead code warnings for utility functions, enums and traits not yet used in production
- Reorganize imports to follow module conventions (e.g., `DeviceIdentity` moved earlier in openhome_renderer.rs)
- Improve formatting of ClientMessage variants for readability
These changes prepare codebase groundwork without altering runtime behavior.
Replace hardcoded relative URLs and manual base_url concatenation with a unified absolute URL API via pmocache::covers_absolute_url_for() and CacheTrait::absolute_url_for().
- Add pmocache as a required dependency to pmoparadise
- Introduce absolute_url_for() and covers_absolute_url_for() helpers using PMO_SERVER_URL env var (default: http://localhost:8080)
- Update all callers to use absolute URLs for covers and audio in streaming, playlists, Qobuz, Radio France, UPnP, and server startup
- Remove redundant route_for() usage in URL construction
- Add pmocache to Cargo.lock
deps: update esbuild to 0.27.4, rollup to 4.60.0, vite to 7.3.1
- bump esbuild and all platform-specific binaries from 0.25.10 to 0.27.4
- bump rollup and all platform-specific binaries from 4.52.3 to 4.60.0
- bump vite from 7.1.7 to 7.3.1 (esbuild peer dep updated to ^0.27.0)
- bump dompurify from 3.2.7 to 3.3.3
web: improve cover image retry logic
- increase maxRetries default from 3 to 5
- reduce initial retryDelay from 1000ms to 500ms
- implement exponential backoff: delay = retryDelay * 2^(retryCount - 1)
- add detailed logging for retries and final failure
rust: minor cleanup
- remove unused imports (watch, Url, AudioSegment, SyncMarker)
- add tracing debug logs for cache file requests
- handle missing files gracefully with warning + client retry hint
- add #[allow(async_fn_in_trait)] where needed
Invalidate the cached OGG header immediately when restarting the FLAC encoder to prevent clients from receiving stale data.
Also improve the player source cleanup by draining the chunk receiver and adding a timeout when waiting for the emit task to finish, preventing potential hangs when the downstream pipeline is saturated.
Migrate from single-client direct OGG-FLAC sink to multi-client broadcast streaming sink.
- Replace DirectOggFlacHandle with OggFlacStreamHandle for multi-client support
- Update sink implementation to use StreamingOggFlacSink with proper backpressure
- Change connection model from 'connect()' to 'subscribe()'
- Adjust stream handling to support independent client streams
- Update stream endpoint to always respond with 200 chunked instead of range requests
- Add tracing for stream lifecycle events
- Reduce OGG channel capacity to strict backpressure (1)
- Add Drop implementation for stream cleanup
- Improve logging and error handling for concurrent access
This change enables multiple simultaneous clients to connect to the same audio stream without interfering with each other, while maintaining proper TCP backpressure and stream lifecycle management.
Switch instance ID storage from localStorage to sessionStorage in useWebRenderer composable to ensure better session management and prevent data persistence across browser sessions.
Also update the DirectOggFlacSink implementation to improve backpressure handling, streamline the OGG chaining logic, and add proper Safari range header support for the stream endpoint.
Cette modification introduit le support du OGG chaining dans le flux audio, permettant une transition transparente entre les pistes sans interruption. Cela inclut la gestion des encodeurs successifs dans le même canal Bytes, l'annulation des encodeurs précédents lors des transitions, et le maintien d'une connexion persistante avec backpressure TCP. Les modifications affectent les composants de sink et de pipeline audio, ainsi que les endpoints d'écoute.
Refactor the audio pipeline to support multi-client streaming with new OggFlacStreamHandle and StreamingOggFlacSink.
- Replace DirectOggFlacSink with StreamingOggFlacSink in pipeline
- Update documentation and comments to reflect multi-client support
- Add detailed warning logs for buffer underruns and client disconnections
- Remove TimerBufferNode from pipeline as it's no longer needed
- Update connect() calls to subscribe() for new streaming behavior
This change enables multiple clients to subscribe to the same audio stream, with each subscription getting a live feed from the current point in time.
This commit refactors the WebRenderer to use a server-side streaming architecture with OGG-FLAC sink instead of the previous WebSocket-based approach. The changes include:
- Replaced WebSocket communication with HTTP streaming using DirectOggFlacSink
- Implemented a new pipeline architecture with dedicated handlers for UPnP commands
- Added new modules for registration, registry, and streaming
- Updated the renderer to work with a pipeline control system
- Removed old WebSocket session management
- Added support for HTTP streaming with gapless playback
- Updated dependencies and features for the new architecture
The WebRenderer now acts as a MediaRenderer UPnP device that serves audio streams via HTTP endpoints, with commands relayed to the audio pipeline through a new control system.
The OGG-FLAC specification requires that each audio data packet contains
one complete FLAC frame. The previous implementation was bundling multiple
FLAC frames into a single OGG page, which caused decode errors in strict
decoders like ffplay/ffmpeg (though VLC was tolerant enough to play it).
Changes:
- Modified broadcast_ogg_flac_stream() to process FLAC frames one at a time
- Each FLAC frame is now wrapped in its own OGG page (per spec)
- Granule position is updated per frame (cumulative sample count)
- Added garbage data detection and skipping
This fixes decode errors while maintaining compatibility with all players.
Ref: https://xiph.org/flac/ogg_mapping.html
"Each audio data packet contains one complete FLAC frame"
Both StreamingFlacSink and StreamingOggFlacSink had duplicate FLAC frame
detection logic. The OGG-FLAC sink had the improved validation, but the
regular FLAC sink was still using the old unvalidated detection.
Changes:
- Created new module: pmoaudio-ext/src/sinks/flac_frame_utils.rs
* parse_flac_block_size() - comprehensive frame header validation
* find_complete_frames_boundary() - for regular FLAC streaming
* find_complete_frames_with_samples() - for OGG-FLAC with granule tracking
* Includes unit tests for validation
- Updated streaming_ogg_flac_sink.rs:
* Removed duplicate functions
* Now uses shared flac_frame_utils module
- Updated streaming_flac_sink.rs:
* Removed old unvalidated find_complete_frames_boundary()
* Now uses shared flac_frame_utils with improved validation
* Benefits from same false positive prevention as OGG-FLAC
- Updated mod.rs to include flac_frame_utils module
Result: Both FLAC and OGG-FLAC streams now use the same comprehensive
frame header validation to prevent false positive sync code detection.
The OGG-FLAC stream was producing decode errors in ffplay/ffmpeg due to
false positive sync code detection. The sync pattern 0xFF 0xF8-0xFE can
appear randomly in compressed audio data, causing invalid frame boundaries.
Changes:
- Enhanced parse_flac_block_size() with comprehensive FLAC frame header validation:
* Reserved bit validation (must be 0)
* Sample rate code validation (0x0F is invalid)
* Channel assignment validation (0x0B-0x0F are reserved)
* Bits per sample validation (0x03 and 0x07 are reserved)
- Fixed frame detection loop to only add validated sync codes to the list
(previously added candidates before validation)
- Removed verbose diagnostic logging
Result: OGG-FLAC stream now decodes correctly in ffplay/ffmpeg without
any 'invalid sync code' or 'invalid frame header' errors.
Tested with: ffmpeg -v error -i http://localhost:8080/test/stream-ogg -f null -
- Added extract_sample_rate_from_streaminfo() to parse STREAMINFO block
- Added debug logs to track frame boundary detection
- Granule position tracking with add_samples()
Problem persists: No OGG pages are broadcast after headers. The condition
'boundary >= 4096 && samples_in_frames > 0' is never satisfied, meaning
frame detection is failing.
Root cause unclear - need deeper investigation of:
1. Why find_complete_frames_with_samples() returns (0, 0)
2. Whether FLAC sync codes are being detected at all
3. If there's an issue with how FLAC encoder outputs data
Added FLAC frame parsing to calculate granule positions, but stream still fails
ffmpeg decode with errors like "invalid sync code", "invalid frame header".
Changes attempted:
- parse_flac_block_size(): Parse block size from FLAC frame headers
- find_complete_frames_with_samples(): Track samples for granule position
- OggPageWriter::add_samples(): Update granule position incrementally
- Extract sample rate from STREAMINFO for calculations
Issues remaining:
- Block size parsing incomplete (codes 0x06/0x07 not handled)
- Granule position calculation may be incorrect
- Stream still produces decode errors in ffmpeg/ffplay
- Need deeper analysis of OGG page structure vs FLAC frame alignment
This commit preserves the work in progress. Further debugging needed to identify
root cause of decode failures.
The previous algorithm was incorrectly finding frame boundaries.
Now properly collects all sync code positions and returns the last one,
ensuring everything before it contains only complete frames.
Changes:
- Collect all sync code positions (0xFF 0xF8-0xFE) in buffer
- Return position of last sync code (start of incomplete frame)
- Everything before this is complete frames ready to send
- Require at least 2 sync codes to identify complete frames
- Lower threshold from 4KB to 1KB for better responsiveness
- Add detailed trace logging for debugging
This should fix "sample/frame number mismatch in adjacent frames" errors.
FFPlay strict decoder requires complete FLAC frames, unlike VLC which is more tolerant.
The previous 512-byte buffer was cutting frames mid-stream, causing sync errors.
Changes:
- Add find_last_flac_frame_boundary() to detect FLAC sync codes (0xFF 0xF8/0xF9)
- Use 16KB read buffer + accumulator to ensure frame-aligned broadcasting
- Only broadcast when we have 4KB+ of complete frames for efficiency
- Use split_off() and mem::replace() for zero-copy buffer management
- Send remaining data on EOF to avoid data loss
This fixes the "invalid sync code" and "invalid frame header" errors in FFPlay
while maintaining compatibility with VLC and other players.
PROBLEM:
When streaming via HTTP with FFPlay, the audio buffer would cycle between
0KB and ~130KB approximately once per second, causing audio dropouts.
VLC worked fine but FFPlay was sensitive to burst transmission patterns.
ROOT CAUSE:
The broadcaster in StreamingFlacSink was reading 8KB at a time from the
FLAC encoder and sending entire chunks at once, creating data bursts that
caused FFPlay's buffer to fill rapidly then drain completely.
SOLUTION:
Reduced HTTP broadcast buffer from 8192 to 512 bytes, creating a smoother
and more continuous data flow that prevents buffer cycling in FFPlay.
CHANGE:
- pmoaudio-ext/src/sinks/streaming_flac_sink.rs:740-742
Changed buffer size from vec![0u8; 8192] to vec![0u8; 512]
The 512-byte size is optimal:
- Small enough to prevent burst transmission
- Large enough to avoid excessive overhead
- Works perfectly with existing real-time pacing logic
TESTING:
Test with: cargo run --example stream_block --features full -- 0
Then: ffplay http://localhost:8080/test/stream
Watch aq= value - should remain stable instead of cycling 0-130KB
Cleaned up excessive INFO logging that was added during debugging.
Logs are now properly categorized by verbosity:
- Frequent/repeated logs (every chunk) → TRACE
* TimerNode SLEEPING messages
* Broadcaster "Read X bytes" messages
- Occasional/setup logs → DEBUG
* Node::run() starting/spawning
* TopZeroSync received
* Cancelled during sleep
- Important events remain INFO
* Encoder initialization
* Header captured
* Stream ended
* Broadcaster task started
This makes INFO logs clean and useful for production monitoring,
while keeping detailed information available via DEBUG/TRACE levels.
Tested with RUST_LOG=info - output is now clean with only
meaningful events logged.
Affected files:
- pmoaudio/src/nodes/timer_node.rs: SLEEPING → trace, TopZeroSync → debug
- pmoaudio/src/pipeline.rs: Node::run/Spawning → debug
- pmoaudio-ext/src/sinks/streaming_flac_sink.rs: Read bytes → trace
Implemented real-time pacing at the HTTP broadcast level based on audio
timestamps propagated from the pipeline. This provides much tighter control
over streaming bandwidth compared to the pipeline TimerNode alone.
Key changes:
- Created PcmChunk struct to carry both PCM bytes and timestamps
- Modified PCM channels from mpsc::channel<Vec<u8>> to mpsc::channel<PcmChunk>
- ByteStreamReader now extracts timestamps and shares them via Arc<RwLock<f64>>
- Broadcasters read current audio timestamp and pace output accordingly
- BROADCAST_MAX_LEAD_TIME set to 0.5s (vs 3.0s for pipeline TimerNode)
Benefits:
- Precise real-time delivery: ~92 KB/s for FLAC, ~86 KB/s for OGG-FLAC
- Lower latency for new clients (0.5s buffer vs 3s)
- Smoother streaming without bursts
- Works with both StreamingFlacSink and StreamingOggFlacSink
Tested:
- FLAC streaming: 92.27 KB/s average over 30s (verified with curl)
- OGG-FLAC streaming: 86.40 KB/s average over 30s
- Both formats correctly identified by file command
- Compilation successful with no errors
Affected files:
- streaming_flac_sink.rs: PcmChunk, ByteStreamReader, broadcast_flac_stream pacing
- streaming_ogg_flac_sink.rs: Same changes for OGG-FLAC variant
Fixed critical busy-loop polling bug in AsyncRead implementations for both
FLAC and OGG-FLAC client streams that prevented data transmission beyond
the initial header.
The issue was calling `cx.waker().wake_by_ref()` immediately when receiving
`TryRecvError::Empty`, creating an infinite poll loop that:
- Never properly waited for new data from the broadcast channel
- Consumed 100% CPU in busy-loop polling
- Prevented clients from receiving stream data after the header
Solution: Replace immediate wake with a delayed waker using tokio::spawn
and tokio::time::sleep(10ms). This avoids the busy-loop while still
ensuring the stream remains responsive to new data.
Testing verified:
- FLAC streaming: 884 KB in 8 seconds (~110 KB/s)
- OGG-FLAC streaming: 892 KB in 8 seconds
- Both formats properly recognized by `file` command
- TimerNode backpressure working correctly (~50ms per chunk)
Affected files:
- streaming_flac_sink.rs: FlacClientStream and IcyClientStream
- streaming_ogg_flac_sink.rs: OggFlacClientStream
Multiple improvements to OGG-FLAC format to better comply with xiph.org spec:
## Changes to streaming_ogg_flac_sink.rs
### 1. Fixed Identification Packet (BOS)
Previously included entire FLAC header (all metadata blocks) in the
identification packet. Now correctly extracts ONLY the STREAMINFO block.
Format now complies with spec:
- Bytes 0: 0x7F
- Bytes 1-4: "FLAC"
- Bytes 5-6: Version 0x01 0x00
- Bytes 7-8: Number of header packets = 1 (was 0, now corrected!)
- Bytes 9-12: "fLaC"
- Bytes 13+: STREAMINFO block only (38 bytes: type + length + 34 bytes data)
Result: Identification packet is now 51 bytes (was 95 bytes)
### 2. Improved FLAC Data Packetization
Changed from arbitrary 4KB chunks to 8KB chunks read directly from encoder.
While not perfect (true spec compliance requires one FLAC frame per OGG packet),
this reduces the chance of splitting frames and improves compatibility.
Proper FLAC frame parsing would require implementing a FLAC frame header parser,
which is complex. Current approach is a pragmatic compromise for streaming.
### 3. Added Debug Logging
- Log STREAMINFO block length (should be 34 bytes)
- Log extracted STREAMINFO size
- Log final identification packet size
- Helps verify spec compliance during development
## Testing
- Compilation successful
- Stream generates correct header size (141 bytes total: 51 + 90)
- STREAMINFO correctly extracted as 38 bytes
- Ready for VLC compatibility testing
## Known Limitations
- Granule position still 0 (should increment with sample count)
- FLAC frame boundaries not perfectly respected (would need frame parser)
- These may be addressed in future iterations if needed for compatibility
