tweaks

Dockerfile

@@ -1,9 +1,10 @@
+# Dockerfile
+
 # Use an official Python runtime as a parent image
 FROM python:3.10-slim-buster
 
 # 1. Install FFmpeg
 # Debian/Ubuntu based images allow easy installation via apt
-# ffmpeg is essential for the conversion process
 RUN apt-get update && \
     apt-get install -y ffmpeg && \
     rm -rf /var/lib/apt/lists/*
@@ -17,13 +18,12 @@ COPY requirements.txt /app/requirements.txt
 # Install Python dependencies, including Gunicorn for production server
 RUN pip install --no-cache-dir -r requirements.txt
 
-# 3. Copy the application code
+# 3. Copy the application code (Ensure this file exists in the same directory!)
 COPY ffmpeg_service.py /app/
 
-# Port 8080 is the standard port for Hugging Face Spaces (hardcoded in CMD)
-EXPOSE 5001
+# Port 8080 is the standard port for Hugging Face Spaces Docker deployments
+EXPOSE 8080
 
 # 4. Run the Flask application using Gunicorn
-# Binds to 0.0.0.0:8080 as required by HF Spaces
-# Format: 'module_name:app_variable_name' -> 'ffmpeg_service:ffmpeg_app'
-CMD exec gunicorn --bind 0.0.0.0:5001 --workers 2 ffmpeg_service:ffmpeg_app
+# Binds to 0.0.0.0:8080
+CMD exec gunicorn --bind 0.0.0.0:8080 --workers 2 ffmpeg_service:ffmpeg_app

app.py

@@ -1,4 +1,4 @@
-# This is a NEW, separate app deployed to a server that has FFmpeg installed (e.g., Hugging Face Space with Docker)
+# ffmpeg_service.py
 
 from flask import Flask, request, Response, stream_with_context
 import requests
@@ -10,8 +10,6 @@ import time
 
 ffmpeg_app = Flask(__name__)
 
-# NOTE: Ensure the 'ffmpeg' binary is available in the environment's PATH
-
 @ffmpeg_app.route('/convert', methods=['GET'])
 def convert_media():
     """
@@ -26,25 +24,25 @@ def convert_media():
     temp_dir = tempfile.mkdtemp()
     
     # Use the original format's extension for the input file to help FFmpeg
-    input_ext = media_url.split('.')[-1].split('?')[0] # Heuristic to get file extension
+    input_ext = media_url.split('.')[-1].split('?')[0]
     input_file_path = os.path.join(temp_dir, f"input.{input_ext}")
     output_file_path = os.path.join(temp_dir, f"output.{target_format}")
 
     try:
         start_time = time.time()
-        print(f"Starting conversion for {target_format} from URL: {media_url[:100]}...")
+        print(f"[{time.strftime('%H:%M:%S')}] Starting conversion for {target_format} from URL: {media_url[:100]}...")
 
         # 1. Download the raw media file to a temporary file
         with requests.get(media_url, stream=True, timeout=120) as r:
             r.raise_for_status()
             content_length = int(r.headers.get('content-length', 0))
-            print(f"Raw media size: {content_length/1024/1024:.2f} MB")
+            print(f"[{time.strftime('%H:%M:%S')}] Raw media size: {content_length/1024/1024:.2f} MB")
             with open(input_file_path, 'wb') as f:
                 for chunk in r.iter_content(chunk_size=8192):
                     f.write(chunk)
         
         download_time = time.time()
-        print(f"Download complete. Time taken: {download_time - start_time:.2f} seconds.")
+        print(f"[{time.strftime('%H:%M:%S')}] Download complete. Time taken: {download_time - start_time:.2f} seconds.")
 
         # 2. Run FFmpeg conversion
         command = [
@@ -54,25 +52,19 @@ def convert_media():
             # Audio-specific options for quality and codec
             '-q:a', '0', # Variable bitrate, highest quality
             '-map', 'a',  # Only include audio streams
-            '-c:a', 'libmp3lame' if target_format == 'mp3' else 'aac', # Use libmp3lame for mp3, aac for m4a/wav if necessary
+            # Codec selection based on format
+            '-c:a', 'libmp3lame' if target_format == 'mp3' else 
+                    ('pcm_s16le' if target_format == 'wav' else 'aac'),
             '-f', target_format,
             output_file_path
         ]
         
-        # Override codec for WAV (PCM uncompressed)
-        if target_format == 'wav':
-             command[9] = 'pcm_s16le' # Use uncompressed PCM 16-bit little-endian
-        elif target_format == 'm4a':
-             command[9] = 'aac'
-
-        
-        process = subprocess.run(command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=180) # 3-minute timeout
+        subprocess.run(command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=180) # 3-minute timeout
         
         conversion_time = time.time()
-        print(f"FFmpeg conversion complete. Time taken: {conversion_time - download_time:.2f} seconds.")
-        # print(f"FFmpeg Output:\n{process.stderr.decode()}")
+        print(f"[{time.strftime('%H:%M:%S')}] FFmpeg conversion complete. Time taken: {conversion_time - download_time:.2f} seconds.")
 
-        # 3. Stream the converted file back to the Vercel app
+        # 3. Stream the converted file back
         def stream_output_file():
             with open(output_file_path, 'rb') as f:
                 chunk = True
@@ -80,28 +72,28 @@ def convert_media():
                     chunk = f.read(8192)
                     yield chunk
 
-        mime_type = f'audio/{target_format}' if target_format != 'm4a' else 'audio/mp4' # m4a is audio/mp4
+        mime_type = f'audio/{target_format}' if target_format != 'm4a' else 'audio/mp4'
         
         return Response(stream_with_context(stream_output_file()), 
-                        mimetype=mime_type,
-                        # Do NOT set Content-Length as it's not possible before streaming starts
-                       )
+                        mimetype=mime_type)
 
     except subprocess.CalledProcessError as e:
-        print(f"FFmpeg command failed with error: {e.stderr.decode()}")
+        print(f"[{time.strftime('%H:%M:%S')}] FFmpeg command failed with error: {e.stderr.decode()}")
         return f"Conversion failed: {e.stderr.decode()}", 500
     except requests.exceptions.Timeout:
-        return "Media download timed out.", 504
+        return "Media download or conversion timed out.", 504
     except Exception as e:
-        print(f"An error occurred in the FFmpeg service: {e}")
+        print(f"[{time.strftime('%H:%M:%S')}] An error occurred in the FFmpeg service: {e}")
         return f"Internal Server Error: {e}", 500
     
     finally:
         # 4. Cleanup temporary files
         if os.path.exists(temp_dir):
             shutil.rmtree(temp_dir)
-            print(f"Cleaned up temp directory: {temp_dir}")
+            print(f"[{time.strftime('%H:%M:%S')}] Cleaned up temp directory: {temp_dir}")
+
 
 if __name__ == '__main__':
-    # You would typically use a WSGI server like Gunicorn in a production Docker deployment
-    ffmpeg_app.run(host='0.0.0.0', port=5001, debug=True)
+    # For local development/testing of the FFmpeg service
+    # NOTE: When deployed via Docker/Gunicorn on Hugging Face, this block is ignored.
+    ffmpeg_app.run(host='0.0.0.0', port=8080, debug=True)