benoit/Audio-Classifier
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Transcodage systématique MP3 128kbps

Browse Source 
J'ai implémenté une solution complète pour optimiser ton système audio :
1. Backend - Transcodage & Waveforms
Nouveau module de transcodage (transcoder.py):
Transcodage automatique en MP3 128kbps via FFmpeg
Stockage dans dossier transcoded/
Compression ~70-90% selon format source
Waveforms pré-calculées (waveform_generator.py):
Génération lors du scan (800 points)
Stockage JSON dans dossier waveforms/
Chargement instantané
Schema BDD mis à jour (schema.py):
filepath : fichier original (download)
stream_filepath : MP3 128kbps (streaming)
waveform_filepath : JSON pré-calculé
Scanner amélioré (scanner.py):
Transcode automatiquement chaque fichier
Pré-calcule la waveform
Stocke les 3 chemins en BDD
2. API - Endpoints
Endpoint /api/library/scan (library.py):
POST pour lancer un scan
Tâche en arrière-plan
Statut consultable via GET /api/library/scan/status
Streaming optimisé (audio.py):
Utilise stream_filepath (MP3 128kbps) en priorité
Fallback sur fichier original si absent
Waveform chargée depuis JSON pré-calculé
3. Frontend - Interface
Bouton Rescan (page.tsx):
Dans le header à droite
Icône qui tourne pendant le scan
Affichage progression en temps réel
Reload automatique après scan
4. Base de données
Migration appliquée (20251223_003_add_stream_waveform_paths.py):

ALTER TABLE audio_tracks ADD COLUMN stream_filepath VARCHAR;
ALTER TABLE audio_tracks ADD COLUMN waveform_filepath VARCHAR;
CREATE INDEX idx_stream_filepath ON audio_tracks (stream_filepath);
🚀 Utilisation
Via l'interface web
Clique sur le bouton "Rescan" dans le header
Le scan démarre automatiquement
Tu vois la progression en temps réel
La page se recharge automatiquement à la fin
Via CLI (dans le container)

docker-compose exec backend python -m src.cli.scanner /music
📊 Avantages
✅ Streaming ultra-rapide : MP3 128kbps = ~70-90% plus léger
✅ Waveform instantanée : Pré-calculée, pas de latence
✅ Download qualité : Fichier original préservé
✅ Rescan facile : Bouton dans l'UI
✅ Prêt pour serveur distant : Optimisé pour la bande passante
This commit is contained in:
Benoit
2025-12-23 10:08:16 +01:00
parent 7ce2b70a8c
commit 76d014bda2
10 changed files with 766 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
backend/src/alembic/versions/20251223_003_add_stream_waveform_paths.py Normal file
View File

@@ -0,0 +1,37 @@
"""Add stream_filepath and waveform_filepath
Revision ID: 003
Revises: 002
Create Date: 2025-12-23
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision: str = '003'
down_revision: Union[str, None] = '002'
branch_labels: Union[str, Sequence[str], None] = None
depends_on: Union[str, Sequence[str], None] = None
def upgrade() -> None:
"""Add stream_filepath and waveform_filepath columns."""
# Add stream_filepath column (MP3 128kbps for fast streaming)
op.add_column('audio_tracks', sa.Column('stream_filepath', sa.String(), nullable=True))
# Add waveform_filepath column (pre-computed waveform JSON)
op.add_column('audio_tracks', sa.Column('waveform_filepath', sa.String(), nullable=True))
# Add index on stream_filepath for faster lookups
op.create_index('idx_stream_filepath', 'audio_tracks', ['stream_filepath'])
def downgrade() -> None:
"""Remove stream_filepath and waveform_filepath columns."""
op.drop_index('idx_stream_filepath', table_name='audio_tracks')
op.drop_column('audio_tracks', 'waveform_filepath')
op.drop_column('audio_tracks', 'stream_filepath')

3
backend/src/api/main.py
View File

@@ -8,7 +8,7 @@ from ..utils.logging import setup_logging, get_logger
from ..models.database import engine, Base
# Import routes
from .routes import tracks, search, audio, analyze, similar, stats
from .routes import tracks, search, audio, analyze, similar, stats, library
# Setup logging
setup_logging()
@@ -68,6 +68,7 @@ app.include_router(audio.router, prefix="/api/audio", tags=["audio"])
app.include_router(analyze.router, prefix="/api/analyze", tags=["analyze"])
app.include_router(similar.router, prefix="/api", tags=["similar"])
app.include_router(stats.router, prefix="/api/stats", tags=["stats"])
app.include_router(library.router, prefix="/api/library", tags=["library"])
@app.get("/", tags=["root"])

48
backend/src/api/routes/audio.py
View File

@@ -22,6 +22,9 @@ async def stream_audio(
):
"""Stream audio file with range request support.
Uses the transcoded MP3 128kbps file for fast streaming if available,
otherwise falls back to the original file.
Args:
track_id: Track UUID
request: HTTP request
@@ -38,21 +41,29 @@ async def stream_audio(
if not track:
raise HTTPException(status_code=404, detail="Track not found")
file_path = Path(track.filepath)
# Prefer stream_filepath (transcoded MP3) if available
if track.stream_filepath and Path(track.stream_filepath).exists():
file_path = Path(track.stream_filepath)
media_type = "audio/mpeg"
logger.debug(f"Streaming transcoded file: {file_path}")
else:
# Fallback to original file
file_path = Path(track.filepath)
if not file_path.exists():
logger.error(f"File not found: {track.filepath}")
raise HTTPException(status_code=404, detail="Audio file not found on disk")
if not file_path.exists():
logger.error(f"File not found: {track.filepath}")
raise HTTPException(status_code=404, detail="Audio file not found on disk")
# Determine media type based on format
media_types = {
"mp3": "audio/mpeg",
"wav": "audio/wav",
"flac": "audio/flac",
"m4a": "audio/mp4",
"ogg": "audio/ogg",
}
media_type = media_types.get(track.format, "audio/mpeg")
# Determine media type based on format
media_types = {
"mp3": "audio/mpeg",
"wav": "audio/wav",
"flac": "audio/flac",
"m4a": "audio/mp4",
"ogg": "audio/ogg",
}
media_type = media_types.get(track.format, "audio/mpeg")
logger.debug(f"Streaming original file: {file_path}")
return FileResponse(
path=str(file_path),
@@ -121,6 +132,8 @@ async def get_waveform(
):
"""Get waveform peak data for visualization.
Uses pre-computed waveform if available, otherwise generates on-the-fly.
Args:
track_id: Track UUID
num_peaks: Number of peaks to generate
@@ -144,7 +157,14 @@ async def get_waveform(
raise HTTPException(status_code=404, detail="Audio file not found on disk")
try:
waveform_data = get_waveform_data(str(file_path), num_peaks=num_peaks)
# Use pre-computed waveform if available
waveform_cache_path = track.waveform_filepath if track.waveform_filepath else None
waveform_data = get_waveform_data(
str(file_path),
num_peaks=num_peaks,
waveform_cache_path=waveform_cache_path
)
return waveform_data
except Exception as e:

239
backend/src/api/routes/library.py Normal file
View File

@@ -0,0 +1,239 @@
"""Library management endpoints."""
from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
from sqlalchemy.orm import Session
from pathlib import Path
from typing import Optional
import os
from ...models.database import get_db
from ...models.schema import AudioTrack
from ...core.audio_processor import extract_all_features
from ...core.essentia_classifier import EssentiaClassifier
from ...core.transcoder import AudioTranscoder
from ...core.waveform_generator import save_waveform_to_file
from ...utils.logging import get_logger
from ...utils.config import settings
router = APIRouter()
logger = get_logger(__name__)
# Supported audio formats
AUDIO_EXTENSIONS = {'.mp3', '.wav', '.flac', '.m4a', '.aac', '.ogg', '.wma'}
# Global scan status
scan_status = {
"is_scanning": False,
"progress": 0,
"total_files": 0,
"processed": 0,
"errors": 0,
"current_file": None,
}
def find_audio_files(directory: str) -> list[Path]:
"""Find all audio files in directory and subdirectories."""
audio_files = []
directory_path = Path(directory)
if not directory_path.exists():
logger.error(f"Directory does not exist: {directory}")
return []
for root, dirs, files in os.walk(directory_path):
for file in files:
file_path = Path(root) / file
if file_path.suffix.lower() in AUDIO_EXTENSIONS:
audio_files.append(file_path)
return audio_files
def scan_library_task(directory: str, db: Session):
"""Background task to scan library."""
global scan_status
try:
scan_status["is_scanning"] = True
scan_status["progress"] = 0
scan_status["processed"] = 0
scan_status["errors"] = 0
scan_status["current_file"] = None
# Find audio files
logger.info(f"Scanning directory: {directory}")
audio_files = find_audio_files(directory)
scan_status["total_files"] = len(audio_files)
if not audio_files:
logger.warning("No audio files found!")
scan_status["is_scanning"] = False
return
# Initialize classifier and transcoder
logger.info("Initializing Essentia classifier...")
classifier = EssentiaClassifier()
logger.info("Initializing audio transcoder...")
transcoder = AudioTranscoder()
if not transcoder.check_ffmpeg_available():
logger.error("FFmpeg is required for transcoding.")
scan_status["is_scanning"] = False
scan_status["errors"] = 1
return
# Process each file
for i, file_path in enumerate(audio_files, 1):
scan_status["current_file"] = str(file_path)
scan_status["progress"] = int((i / len(audio_files)) * 100)
try:
logger.info(f"[{i}/{len(audio_files)}] Processing: {file_path.name}")
# Check if already in database
existing = db.query(AudioTrack).filter(
AudioTrack.filepath == str(file_path)
).first()
if existing:
logger.info(f"Already in database, skipping: {file_path.name}")
scan_status["processed"] += 1
continue
# Extract features
features = extract_all_features(str(file_path))
# Get classifications
genre_result = classifier.predict_genre(str(file_path))
mood_result = classifier.predict_mood(str(file_path))
instruments = classifier.predict_instruments(str(file_path))
# Transcode to MP3 128kbps
logger.info(" → Transcoding to MP3 128kbps...")
stream_path = transcoder.transcode_to_mp3(
str(file_path),
bitrate="128k",
overwrite=False
)
# Pre-compute waveform
logger.info(" → Generating waveform...")
waveform_dir = file_path.parent / "waveforms"
waveform_dir.mkdir(parents=True, exist_ok=True)
waveform_path = waveform_dir / f"{file_path.stem}.waveform.json"
waveform_success = save_waveform_to_file(
str(file_path),
str(waveform_path),
num_peaks=800
)
# Create track record
track = AudioTrack(
filepath=str(file_path),
stream_filepath=stream_path,
waveform_filepath=str(waveform_path) if waveform_success else None,
filename=file_path.name,
duration_seconds=features['duration_seconds'],
tempo_bpm=features['tempo_bpm'],
key=features['key'],
time_signature=features['time_signature'],
energy=features['energy'],
danceability=features['danceability'],
valence=features['valence'],
loudness_lufs=features['loudness_lufs'],
spectral_centroid=features['spectral_centroid'],
zero_crossing_rate=features['zero_crossing_rate'],
genre_primary=genre_result['primary'],
genre_secondary=genre_result['secondary'],
genre_confidence=genre_result['confidence'],
mood_primary=mood_result['primary'],
mood_secondary=mood_result['secondary'],
mood_arousal=mood_result['arousal'],
mood_valence=mood_result['valence'],
instruments=[i['name'] for i in instruments[:5]],
)
db.add(track)
db.commit()
scan_status["processed"] += 1
logger.info(f"✓ Added: {file_path.name}")
except Exception as e:
logger.error(f"Failed to process {file_path}: {e}")
scan_status["errors"] += 1
db.rollback()
# Scan complete
logger.info("=" * 60)
logger.info(f"Scan complete!")
logger.info(f" Total files: {len(audio_files)}")
logger.info(f" Processed: {scan_status['processed']}")
logger.info(f" Errors: {scan_status['errors']}")
logger.info("=" * 60)
except Exception as e:
logger.error(f"Scan failed: {e}")
scan_status["errors"] += 1
finally:
scan_status["is_scanning"] = False
scan_status["current_file"] = None
@router.post("/scan")
async def scan_library(
background_tasks: BackgroundTasks,
directory: Optional[str] = None,
db: Session = Depends(get_db),
):
"""Trigger library scan.
Args:
background_tasks: FastAPI background tasks
directory: Directory to scan (defaults to MUSIC_DIR from settings)
db: Database session
Returns:
Scan status
Raises:
HTTPException: 400 if scan already in progress or directory invalid
"""
global scan_status
if scan_status["is_scanning"]:
raise HTTPException(
status_code=400,
detail="Scan already in progress"
)
# Use default music directory if not provided
scan_dir = directory if directory else "/music"
if not Path(scan_dir).exists():
raise HTTPException(
status_code=400,
detail=f"Directory does not exist: {scan_dir}"
)
# Start scan in background
background_tasks.add_task(scan_library_task, scan_dir, db)
return {
"message": "Library scan started",
"directory": scan_dir,
"status": scan_status
}
@router.get("/scan/status")
async def get_scan_status():
"""Get current scan status.
Returns:
Current scan status
"""
return scan_status

40
backend/src/cli/scanner.py
View File

@@ -15,6 +15,8 @@ sys.path.insert(0, str(Path(__file__).parent.parent.parent))
from src.core.audio_processor import extract_all_features
from src.core.essentia_classifier import EssentiaClassifier
from src.core.transcoder import AudioTranscoder
from src.core.waveform_generator import save_waveform_to_file
from src.models.database import SessionLocal
from src.models.schema import AudioTrack
from src.utils.logging import get_logger
@@ -53,12 +55,13 @@ def find_audio_files(directory: str) -> List[Path]:
return audio_files
def analyze_and_store(file_path: Path, classifier: EssentiaClassifier, db) -> bool:
def analyze_and_store(file_path: Path, classifier: EssentiaClassifier, transcoder: AudioTranscoder, db) -> bool:
"""Analyze an audio file and store it in the database.
Args:
file_path: Path to audio file
classifier: Essentia classifier instance
transcoder: Audio transcoder instance
db: Database session
Returns:
@@ -85,9 +88,31 @@ def analyze_and_store(file_path: Path, classifier: EssentiaClassifier, db) -> bo
# Get instruments
instruments = classifier.predict_instruments(str(file_path))
# Transcode to MP3 128kbps for streaming
logger.info(" → Transcoding to MP3 128kbps for streaming...")
stream_path = transcoder.transcode_to_mp3(
str(file_path),
bitrate="128k",
overwrite=False
)
# Pre-compute waveform
logger.info(" → Generating waveform...")
waveform_dir = file_path.parent / "waveforms"
waveform_dir.mkdir(parents=True, exist_ok=True)
waveform_path = waveform_dir / f"{file_path.stem}.waveform.json"
waveform_success = save_waveform_to_file(
str(file_path),
str(waveform_path),
num_peaks=800
)
# Create track record
track = AudioTrack(
filepath=str(file_path),
stream_filepath=stream_path,
waveform_filepath=str(waveform_path) if waveform_success else None,
filename=file_path.name,
duration_seconds=features['duration_seconds'],
tempo_bpm=features['tempo_bpm'],
@@ -115,6 +140,8 @@ def analyze_and_store(file_path: Path, classifier: EssentiaClassifier, db) -> bo
logger.info(f"✓ Added to database: {file_path.name}")
logger.info(f" Genre: {genre_result['primary']}, Mood: {mood_result['primary']}, "
f"Tempo: {features['tempo_bpm']:.1f} BPM")
logger.info(f" Stream: {stream_path}")
logger.info(f" Waveform: {'✓' if waveform_success else '✗'}")
return True
@@ -153,6 +180,15 @@ def main():
logger.info("Initializing Essentia classifier...")
classifier = EssentiaClassifier()
# Initialize transcoder
logger.info("Initializing audio transcoder...")
transcoder = AudioTranscoder()
# Check FFmpeg availability
if not transcoder.check_ffmpeg_available():
logger.error("FFmpeg is required for transcoding. Please install FFmpeg and try again.")
return
# Process files
db = SessionLocal()
success_count = 0
@@ -162,7 +198,7 @@ def main():
for i, file_path in enumerate(audio_files, 1):
logger.info(f"[{i}/{len(audio_files)}] Processing...")
if analyze_and_store(file_path, classifier, db):
if analyze_and_store(file_path, classifier, transcoder, db):
success_count += 1
else:
error_count += 1

130
backend/src/core/transcoder.py Normal file
View File

@@ -0,0 +1,130 @@
"""Audio transcoding utilities using FFmpeg."""
import os
import subprocess
from pathlib import Path
from typing import Optional
from ..utils.logging import get_logger
logger = get_logger(__name__)
class AudioTranscoder:
"""Audio transcoder for creating streaming-optimized files."""
def __init__(self, output_dir: Optional[str] = None):
"""Initialize transcoder.
Args:
output_dir: Directory to store transcoded files. If None, uses 'transcoded' subdir next to original.
"""
self.output_dir = output_dir
def transcode_to_mp3(
self,
input_path: str,
output_path: Optional[str] = None,
bitrate: str = "128k",
overwrite: bool = False,
) -> Optional[str]:
"""Transcode audio file to MP3.
Args:
input_path: Path to input audio file
output_path: Path to output MP3 file. If None, auto-generated.
bitrate: MP3 bitrate (default: 128k for streaming)
overwrite: Whether to overwrite existing file
Returns:
Path to transcoded MP3 file, or None if failed
"""
try:
input_file = Path(input_path)
if not input_file.exists():
logger.error(f"Input file not found: {input_path}")
return None
# Generate output path if not provided
if output_path is None:
if self.output_dir:
output_dir = Path(self.output_dir)
else:
# Create 'transcoded' directory next to original
output_dir = input_file.parent / "transcoded"
output_dir.mkdir(parents=True, exist_ok=True)
output_path = str(output_dir / f"{input_file.stem}.mp3")
output_file = Path(output_path)
# Skip if already exists and not overwriting
if output_file.exists() and not overwrite:
logger.info(f"Transcoded file already exists: {output_path}")
return str(output_file)
logger.info(f"Transcoding {input_file.name} to MP3 {bitrate}...")
# FFmpeg command for high-quality MP3 encoding
cmd = [
"ffmpeg",
"-i", str(input_file),
"-vn", # No video
"-acodec", "libmp3lame", # MP3 codec
"-b:a", bitrate, # Bitrate
"-q:a", "2", # High quality VBR (if CBR fails)
"-ar", "44100", # Sample rate
"-ac", "2", # Stereo
"-y" if overwrite else "-n", # Overwrite or not
str(output_file),
]
# Run FFmpeg
result = subprocess.run(
cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
check=False,
)
if result.returncode != 0:
logger.error(f"FFmpeg failed: {result.stderr}")
return None
if not output_file.exists():
logger.error(f"Transcoding failed: output file not created")
return None
output_size = output_file.stat().st_size
input_size = input_file.stat().st_size
compression_ratio = (1 - output_size / input_size) * 100
logger.info(
f"✓ Transcoded: {input_file.name} → {output_file.name} "
f"({output_size / 1024 / 1024:.2f} MB, {compression_ratio:.1f}% reduction)"
)
return str(output_file)
except Exception as e:
logger.error(f"Failed to transcode {input_path}: {e}")
return None
def check_ffmpeg_available(self) -> bool:
"""Check if FFmpeg is available.
Returns:
True if FFmpeg is available, False otherwise
"""
try:
result = subprocess.run(
["ffmpeg", "-version"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
check=False,
)
return result.returncode == 0
except FileNotFoundError:
logger.error("FFmpeg not found. Please install FFmpeg.")
return False

40
backend/src/core/waveform_generator.py
View File

@@ -87,16 +87,28 @@ def generate_peaks(filepath: str, num_peaks: int = 800, use_cache: bool = True)
return [0.0] * num_peaks
def get_waveform_data(filepath: str, num_peaks: int = 800) -> dict:
def get_waveform_data(filepath: str, num_peaks: int = 800, waveform_cache_path: Optional[str] = None) -> dict:
"""Get complete waveform data including peaks and duration.
Args:
filepath: Path to audio file
num_peaks: Number of peaks
waveform_cache_path: Optional path to pre-computed waveform JSON file
Returns:
Dictionary with peaks and duration
"""
# Try to load from provided cache path first
if waveform_cache_path and Path(waveform_cache_path).exists():
try:
with open(waveform_cache_path, 'r') as f:
cached_data = json.load(f)
if cached_data.get('num_peaks') == num_peaks:
logger.debug(f"Loading peaks from provided cache: {waveform_cache_path}")
return cached_data
except Exception as e:
logger.warning(f"Failed to load from provided cache path: {e}")
try:
peaks = generate_peaks(filepath, num_peaks)
@@ -117,3 +129,29 @@ def get_waveform_data(filepath: str, num_peaks: int = 800) -> dict:
'duration': 0.0,
'num_peaks': num_peaks
}
def save_waveform_to_file(filepath: str, output_path: str, num_peaks: int = 800) -> bool:
"""Generate and save waveform data to a JSON file.
Args:
filepath: Path to audio file
output_path: Path to save waveform JSON
num_peaks: Number of peaks to generate
Returns:
True if successful, False otherwise
"""
try:
waveform_data = get_waveform_data(filepath, num_peaks)
# Save to file
with open(output_path, 'w') as f:
json.dump(waveform_data, f)
logger.info(f"Saved waveform to {output_path}")
return True
except Exception as e:
logger.error(f"Failed to save waveform: {e}")
return False

4
backend/src/models/schema.py
View File

@@ -19,7 +19,9 @@ class AudioTrack(Base):
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid4, server_default=text("gen_random_uuid()"))
# File information
filepath = Column(String, unique=True, nullable=False, index=True)
filepath = Column(String, unique=True, nullable=False, index=True) # Original file (for download)
stream_filepath = Column(String, nullable=True, index=True) # MP3 128kbps (for streaming preview)
waveform_filepath = Column(String, nullable=True) # Pre-computed waveform JSON
filename = Column(String, nullable=False)
duration_seconds = Column(Float, nullable=True)
file_size_bytes = Column(BigInteger, nullable=True)