Spaces:

unveilAiDotOrg
/

audio-processor

Running

App Files Files Community

tedowski commited on Jun 8, 2025

Commit

aebd124

verified ·

1 Parent(s): 72e8a3d

Update app.py

Browse files

Files changed (1) hide show

app.py +508 -5

app.py CHANGED Viewed

@@ -1,7 +1,510 @@
-from fastapi import FastAPI
-app = FastAPI()
-@app.get("/")
-def greet_json():
-    return {"Hello": "World!"}

+from fastapi import FastAPI, UploadFile, File, HTTPException, BackgroundTasks, Form
+from fastapi.responses import FileResponse, JSONResponse, HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+import ffmpeg
+import tempfile
+import os
+import uuid
+from datetime import datetime, timedelta
+import asyncio
+import aiofiles
+from typing import Optional, Dict, Any
+import logging
+import shutil
+from pathlib import Path
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+app = FastAPI(
+    title="Video to Audio Extractor",
+    description="Extract audio from video files using FFmpeg",
+    version="1.0.0"
+)
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+# Storage for background jobs
+processing_jobs: Dict[str, Any] = {}
+# Temporary directory for file storage
+TEMP_DIR = Path("/tmp/audio_extractor")
+TEMP_DIR.mkdir(exist_ok=True)
+# Supported formats
+SUPPORTED_VIDEO_FORMATS = ['.mp4', '.avi', '.mov', '.mkv', '.webm', '.flv', '.wmv', '.m4v']
+SUPPORTED_AUDIO_FORMATS = ['mp3', 'aac', 'wav', 'flac', 'm4a', 'ogg']
+# Quality settings for different formats
+QUALITY_SETTINGS = {
+    'mp3': {
+        'high': {'audio_bitrate': '320k', 'acodec': 'libmp3lame'},
+        'medium': {'audio_bitrate': '192k', 'acodec': 'libmp3lame'},
+        'low': {'audio_bitrate': '128k', 'acodec': 'libmp3lame'}
+    },
+    'aac': {
+        'high': {'audio_bitrate': '256k', 'acodec': 'aac'},
+        'medium': {'audio_bitrate': '192k', 'acodec': 'aac'},
+        'low': {'audio_bitrate': '128k', 'acodec': 'aac'}
+    },
+    'wav': {
+        'high': {'acodec': 'pcm_s24le'},
+        'medium': {'acodec': 'pcm_s16le'},
+        'low': {'acodec': 'pcm_s16le'}
+    },
+    'flac': {
+        'high': {'acodec': 'flac', 'compression_level': 12},
+        'medium': {'acodec': 'flac', 'compression_level': 8},
+        'low': {'acodec': 'flac', 'compression_level': 0}
+    },
+    'm4a': {
+        'high': {'audio_bitrate': '256k', 'acodec': 'aac'},
+        'medium': {'audio_bitrate': '192k', 'acodec': 'aac'},
+        'low': {'audio_bitrate': '128k', 'acodec': 'aac'}
+    },
+    'ogg': {
+        'high': {'audio_bitrate': '256k', 'acodec': 'libvorbis'},
+        'medium': {'audio_bitrate': '192k', 'acodec': 'libvorbis'},
+        'low': {'audio_bitrate': '128k', 'acodec': 'libvorbis'}
+    }
+}
+def get_media_type(format: str) -> str:
+    """Get the correct media type for audio format."""
+    media_types = {
+        'mp3': 'audio/mpeg',
+        'aac': 'audio/aac',
+        'wav': 'audio/wav',
+        'flac': 'audio/flac',
+        'm4a': 'audio/mp4',
+        'ogg': 'audio/ogg'
+    }
+    return media_types.get(format, 'audio/mpeg')
+@app.get("/", response_class=HTMLResponse)
+async def home():
+    """Simple HTML interface for testing."""
+    return """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Video to Audio Extractor</title>
+        <style>
+            body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
+            .container { background: #f5f5f5; padding: 20px; border-radius: 8px; }
+            h1 { color: #333; }
+            form { margin-top: 20px; }
+            label { display: block; margin-top: 10px; font-weight: bold; }
+            input, select { width: 100%; padding: 8px; margin-top: 5px; border: 1px solid #ddd; border-radius: 4px; }
+            button { background: #007bff; color: white; padding: 10px 20px; border: none; border-radius: 4px; margin-top: 20px; cursor: pointer; }
+            button:hover { background: #0056b3; }
+            #result { margin-top: 20px; padding: 10px; background: #e9ecef; border-radius: 4px; display: none; }
+            .error { color: #dc3545; }
+            .success { color: #28a745; }
+            .loading { color: #17a2b8; }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>🎵 Video to Audio Extractor</h1>
+            <p>Upload a video file to extract its audio track.</p>
+            <form id="uploadForm">
+                <label>Video File:</label>
+                <input type="file" id="videoFile" accept="video/*" required>
+                <label>Output Format:</label>
+                <select id="format">
+                    <option value="mp3">MP3</option>
+                    <option value="aac">AAC</option>
+                    <option value="wav">WAV</option>
+                    <option value="flac">FLAC</option>
+                    <option value="m4a">M4A</option>
+                    <option value="ogg">OGG</option>
+                </select>
+                <label>Quality:</label>
+                <select id="quality">
+                    <option value="high">High</option>
+                    <option value="medium" selected>Medium</option>
+                    <option value="low">Low</option>
+                </select>
+                <button type="submit">Extract Audio</button>
+            </form>
+            <div id="result"></div>
+        </div>
+        <script>
+            document.getElementById('uploadForm').onsubmit = async (e) => {
+                e.preventDefault();
+                const resultDiv = document.getElementById('result');
+                const file = document.getElementById('videoFile').files[0];
+                const format = document.getElementById('format').value;
+                const quality = document.getElementById('quality').value;
+                if (!file) {
+                    resultDiv.innerHTML = '<p class="error">Please select a file</p>';
+                    resultDiv.style.display = 'block';
+                    return;
+                }
+                resultDiv.innerHTML = '<p class="loading">Processing... This may take a moment.</p>';
+                resultDiv.style.display = 'block';
+                const formData = new FormData();
+                formData.append('video', file);
+                formData.append('output_format', format);
+                formData.append('quality', quality);
+                try {
+                    const response = await fetch('/extract-audio', {
+                        method: 'POST',
+                        body: formData
+                    });
+                    if (response.headers.get('content-type')?.includes('audio')) {
+                        // Direct file response
+                        const blob = await response.blob();
+                        const url = URL.createObjectURL(blob);
+                        resultDiv.innerHTML = `
+                            <p class="success">✅ Audio extracted successfully!</p>
+                            <audio controls src="${url}"></audio>
+                            <br><br>
+                            <a href="${url}" download="extracted_audio.${format}">
+                                <button>Download Audio</button>
+                            </a>
+                        `;
+                    } else {
+                        // Job response
+                        const data = await response.json();
+                        if (data.job_id) {
+                            resultDiv.innerHTML = '<p class="loading">Processing large file...</p>';
+                            checkJobStatus(data.job_id, format);
+                        } else {
+                            throw new Error(data.error || 'Unknown error');
+                        }
+                    }
+                } catch (error) {
+                    resultDiv.innerHTML = `<p class="error">Error: ${error.message}</p>`;
+                }
+            };
+            async function checkJobStatus(jobId, format) {
+                const resultDiv = document.getElementById('result');
+                const checkInterval = setInterval(async () => {
+                    try {
+                        const response = await fetch(`/status/${jobId}`);
+                        const data = await response.json();
+                        if (data.status === 'completed') {
+                            clearInterval(checkInterval);
+                            resultDiv.innerHTML = `
+                                <p class="success">✅ Audio extracted successfully!</p>
+                                <a href="/download/${jobId}" download="extracted_audio.${format}">
+                                    <button>Download Audio</button>
+                                </a>
+                            `;
+                        } else if (data.status === 'failed') {
+                            clearInterval(checkInterval);
+                            resultDiv.innerHTML = `<p class="error">Error: ${data.error}</p>`;
+                        }
+                    } catch (error) {
+                        clearInterval(checkInterval);
+                        resultDiv.innerHTML = `<p class="error">Error checking status: ${error.message}</p>`;
+                    }
+                }, 2000);
+            }
+        </script>
+    </body>
+    </html>
+    """
+@app.post("/extract-audio")
+async def extract_audio(
+    background_tasks: BackgroundTasks,
+    video: UploadFile = File(...),
+    output_format: str = Form("mp3"),
+    quality: str = Form("medium")
+):
+    """Extract audio from uploaded video file."""
+    # Validate input format
+    if output_format not in SUPPORTED_AUDIO_FORMATS:
+        raise HTTPException(400, f"Unsupported output format. Supported: {', '.join(SUPPORTED_AUDIO_FORMATS)}")
+    # Validate video file extension
+    file_ext = Path(video.filename).suffix.lower()
+    if file_ext not in SUPPORTED_VIDEO_FORMATS:
+        raise HTTPException(400, f"Unsupported video format. Supported: {', '.join(SUPPORTED_VIDEO_FORMATS)}")
+    # Check file size (in MB)
+    video.file.seek(0, 2)  # Seek to end
+    file_size = video.file.tell()
+    video.file.seek(0)  # Reset to beginning
+    file_size_mb = file_size / (1024 * 1024)
+    logger.info(f"Processing video: {video.filename} ({file_size_mb:.1f} MB) -> {output_format} ({quality})")
+    # Decide processing method based on file size
+    if file_size_mb < 10:  # Small files: process immediately
+        try:
+            return await process_and_return_direct(video, output_format, quality)
+        except Exception as e:
+            logger.error(f"Error processing video: {str(e)}")
+            raise HTTPException(500, f"Processing failed: {str(e)}")
+    else:  # Large files: process in background
+        job_id = str(uuid.uuid4())
+        background_tasks.add_task(
+            process_in_background,
+            job_id, video, output_format, quality, file_size_mb
+        )
+        return JSONResponse({
+            "job_id": job_id,
+            "status": "processing",
+            "message": f"Processing large file ({file_size_mb:.1f} MB). Check status at /status/{job_id}",
+            "check_url": f"/status/{job_id}"
+        })
+async def process_and_return_direct(video: UploadFile, output_format: str, quality: str) -> FileResponse:
+    """Process video and return audio file directly."""
+    # Create temporary files
+    with tempfile.NamedTemporaryFile(delete=False, suffix=Path(video.filename).suffix) as tmp_video:
+        # Save uploaded video
+        content = await video.read()
+        tmp_video.write(content)
+        tmp_video_path = tmp_video.name
+    try:
+        # Extract audio
+        output_path = await extract_audio_ffmpeg(tmp_video_path, output_format, quality)
+        # Create response that will clean up files after sending
+        def cleanup():
+            try:
+                os.unlink(tmp_video_path)
+                os.unlink(output_path)
+            except:
+                pass
+        background_tasks = BackgroundTasks()
+        background_tasks.add_task(cleanup)
+        return FileResponse(
+            output_path,
+            media_type=get_media_type(output_format),
+            filename=f"{Path(video.filename).stem}.{output_format}",
+            background=background_tasks
+        )
+    except Exception as e:
+        # Cleanup on error
+        if os.path.exists(tmp_video_path):
+            os.unlink(tmp_video_path)
+        raise
+async def extract_audio_ffmpeg(input_path: str, output_format: str, quality: str) -> str:
+    """Extract audio using FFmpeg."""
+    # Generate output path
+    output_path = str(TEMP_DIR / f"{uuid.uuid4()}.{output_format}")
+    # Get quality settings
+    settings = QUALITY_SETTINGS.get(output_format, {}).get(quality, {})
+    try:
+        # Build FFmpeg command
+        stream = ffmpeg.input(input_path)
+        stream = stream.audio  # Extract only audio stream
+        # Apply format-specific settings
+        stream = ffmpeg.output(stream, output_path, **settings)
+        # Run FFmpeg
+        await asyncio.get_event_loop().run_in_executor(
+            None,
+            lambda: ffmpeg.run(stream, overwrite_output=True, capture_stdout=True, capture_stderr=True)
+        )
+        logger.info(f"Audio extracted successfully: {output_path}")
+        return output_path
+    except ffmpeg.Error as e:
+        logger.error(f"FFmpeg error: {e.stderr.decode()}")
+        raise Exception(f"FFmpeg processing failed: {e.stderr.decode()}")
+async def process_in_background(job_id: str, video: UploadFile, output_format: str, quality: str, file_size_mb: float):
+    """Process large video files in background."""
+    # Update job status
+    processing_jobs[job_id] = {
+        'status': 'processing',
+        'started_at': datetime.now(),
+        'filename': video.filename,
+        'file_size_mb': file_size_mb,
+        'format': output_format,
+        'quality': quality
+    }
+    tmp_video_path = None
+    output_path = None
+    try:
+        # Save video to temporary file
+        tmp_video_path = str(TEMP_DIR / f"{job_id}_input{Path(video.filename).suffix}")
+        async with aiofiles.open(tmp_video_path, 'wb') as f:
+            while chunk := await video.read(1024 * 1024):  # Read in 1MB chunks
+                await f.write(chunk)
+        # Extract audio
+        output_path = await extract_audio_ffmpeg(tmp_video_path, output_format, quality)
+        # Update job status
+        processing_jobs[job_id].update({
+            'status': 'completed',
+            'output_path': output_path,
+            'completed_at': datetime.now(),
+            'download_url': f'/download/{job_id}'
+        })
+        logger.info(f"Background job {job_id} completed successfully")
+    except Exception as e:
+        logger.error(f"Background job {job_id} failed: {str(e)}")
+        processing_jobs[job_id].update({
+            'status': 'failed',
+            'error': str(e),
+            'failed_at': datetime.now()
+        })
+    finally:
+        # Clean up input file
+        if tmp_video_path and os.path.exists(tmp_video_path):
+            try:
+                os.unlink(tmp_video_path)
+            except:
+                pass
+@app.get("/status/{job_id}")
+async def check_status(job_id: str):
+    """Check the status of a background processing job."""
+    job = processing_jobs.get(job_id)
+    if not job:
+        raise HTTPException(404, "Job not found")
+    # Calculate processing time
+    if job['status'] == 'processing':
+        duration = (datetime.now() - job['started_at']).total_seconds()
+        job['processing_time_seconds'] = duration
+    elif job['status'] == 'completed':
+        duration = (job['completed_at'] - job['started_at']).total_seconds()
+        job['processing_time_seconds'] = duration
+    # Don't expose internal paths
+    safe_job = {k: v for k, v in job.items() if k != 'output_path'}
+    return safe_job
+@app.get("/download/{job_id}")
+async def download_result(job_id: str):
+    """Download the processed audio file."""
+    job = processing_jobs.get(job_id)
+    if not job:
+        raise HTTPException(404, "Job not found")
+    if job['status'] != 'completed':
+        raise HTTPException(400, f"Job status: {job['status']}")
+    if not os.path.exists(job['output_path']):
+        raise HTTPException(404, "Output file not found")
+    filename = f"{Path(job['filename']).stem}.{job['format']}"
+    return FileResponse(
+        job['output_path'],
+        media_type=get_media_type(job['format']),
+        filename=filename
+    )
+@app.get("/api/info")
+async def api_info():
+    """Get API information and supported formats."""
+    return {
+        "supported_video_formats": SUPPORTED_VIDEO_FORMATS,
+        "supported_audio_formats": SUPPORTED_AUDIO_FORMATS,
+        "quality_levels": ["high", "medium", "low"],
+        "max_direct_response_size_mb": 10,
+        "endpoints": {
+            "/": "Web interface",
+            "/extract-audio": "POST - Extract audio from video",
+            "/status/{job_id}": "GET - Check job status",
+            "/download/{job_id}": "GET - Download processed audio",
+            "/api/info": "GET - API information"
+        }
+    }
+# Cleanup task
+async def cleanup_old_files():
+    """Periodically clean up old temporary files."""
+    while True:
+        try:
+            await asyncio.sleep(3600)  # Run every hour
+            now = datetime.now()
+            cleaned_count = 0
+            # Clean up completed/failed jobs older than 2 hours
+            for job_id, job in list(processing_jobs.items()):
+                job_age = now - job.get('started_at', now)
+                if job_age > timedelta(hours=2):
+                    # Delete output file if exists
+                    if 'output_path' in job and os.path.exists(job['output_path']):
+                        try:
+                            os.unlink(job['output_path'])
+                            cleaned_count += 1
+                        except:
+                            pass
+                    del processing_jobs[job_id]
+            # Clean up orphaned files in temp directory
+            for file_path in TEMP_DIR.glob('*'):
+                if file_path.is_file():
+                    file_age = now - datetime.fromtimestamp(file_path.stat().st_mtime)
+                    if file_age > timedelta(hours=2):
+                        try:
+                            file_path.unlink()
+                            cleaned_count += 1
+                        except:
+                            pass
+            if cleaned_count > 0:
+                logger.info(f"Cleanup: removed {cleaned_count} old files")
+        except Exception as e:
+            logger.error(f"Cleanup error: {str(e)}")
+@app.on_event("startup")
+async def startup_event():
+    """Start background tasks on app startup."""
+    asyncio.create_task(cleanup_old_files())
+    logger.info("Audio extractor service started")
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Clean up on shutdown."""
+    # Clean all temporary files
+    try:
+        shutil.rmtree(TEMP_DIR)
+    except:
+        pass
+    logger.info("Audio extractor service stopped")