update

app.py

@@ -3,12 +3,14 @@ import subprocess
 import os
 import uuid
 import tempfile
+import urllib.request
+import urllib.parse
 
 app = Flask(__name__)
 
 # Folder untuk simpan hasil
 # OUTPUT_DIR = "downloads"
-OUTPUT_DIR = "/tmp/downloads" 
+OUTPUT_DIR = "/tmp/downloads"
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 def run_cmd(args, shell=False):
@@ -95,6 +97,64 @@ def probe_media_duration_seconds(input_path):
         pass
     return None
 
+def _guess_extension_from_url_or_ct(url, content_type, fallback_ext):
+    try:
+        # Try from URL path
+        path = urllib.parse.urlparse(url).path
+        ext = os.path.splitext(path)[1]
+        if ext:
+            return ext
+    except Exception:
+        pass
+    # Fallback from content-type
+    if content_type:
+        ct = content_type.lower().split(';')[0].strip()
+        mapping = {
+            'image/jpeg': '.jpg',
+            'image/jpg': '.jpg',
+            'image/png': '.png',
+            'image/webp': '.webp',
+            'image/bmp': '.bmp',
+            'image/gif': '.gif',
+            'audio/mpeg': '.mp3',
+            'audio/mp3': '.mp3',
+            'audio/aac': '.aac',
+            'audio/wav': '.wav',
+            'audio/x-wav': '.wav',
+            'audio/flac': '.flac',
+            'audio/ogg': '.ogg',
+            'audio/webm': '.webm',
+        }
+        if ct in mapping:
+            return mapping[ct]
+    return fallback_ext
+
+def download_url_to_file(src_url, default_ext):
+    """Download a URL to a temp file under OUTPUT_DIR, return the file path.
+
+    This avoids extra deps; uses urllib with a sensible timeout.
+    """
+    try:
+        req = urllib.request.Request(src_url, headers={
+            'User-Agent': 'Mozilla/5.0 (compatible; image-audio-fetcher)'
+        })
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            content_type = resp.headers.get('Content-Type', '')
+            ext = _guess_extension_from_url_or_ct(src_url, content_type, default_ext)
+            temp_name = f"dl_{uuid.uuid4().hex}{ext}"
+            out_path = os.path.join(OUTPUT_DIR, temp_name)
+            with open(out_path, 'wb') as f:
+                while True:
+                    chunk = resp.read(1024 * 64)
+                    if not chunk:
+                        break
+                    f.write(chunk)
+        if not os.path.exists(out_path) or os.path.getsize(out_path) == 0:
+            raise RuntimeError('Downloaded file is empty')
+        return out_path
+    except Exception as e:
+        raise RuntimeError(str(e))
+
 @app.route('/image-to-video', methods=['POST'])
 def image_to_video():
     """Create a video from a still image and an audio file.
@@ -239,6 +299,146 @@ def image_to_video():
             pass
     return response
 
+@app.route('/image-to-video-url', methods=['POST'])
+def image_to_video_url():
+    """Create a video from image_url + audio_url (JSON body).
+
+    JSON fields:
+    - image_url (required)
+    - audio_url (required)
+    - duration (required unless audio_start/audio_end provided) seconds or HH:MM:SS
+    - audio_start (optional) seconds or HH:MM:SS
+    - audio_end (optional) seconds or HH:MM:SS
+    - resolution (optional) preset or WIDTHxHEIGHT
+    - fit (optional) 'pad' (default) or 'crop'
+    """
+    try:
+        data = request.get_json(silent=True) or {}
+    except Exception:
+        data = {}
+
+    # Support JSON body and/or query params as fallback
+    image_url = (data.get('image_url') or request.args.get('image_url') or '').strip()
+    audio_url = (data.get('audio_url') or request.args.get('audio_url') or '').strip()
+    duration_str = data.get('duration') if 'duration' in data else request.args.get('duration')
+    audio_start_str = data.get('audio_start') if 'audio_start' in data else request.args.get('audio_start')
+    audio_end_str = data.get('audio_end') if 'audio_end' in data else request.args.get('audio_end')
+    resolution = data.get('resolution') if 'resolution' in data else request.args.get('resolution')
+    fit = (data.get('fit') if 'fit' in data else request.args.get('fit') or 'pad').lower()
+
+    if not image_url or not audio_url:
+        return jsonify({"error": "Harap kirim image_url dan audio_url"}), 400
+
+    # Resolve timing parameters
+    audio_start_sec = None
+    audio_end_sec = None
+    duration_sec = None
+
+    if audio_start_str:
+        audio_start_sec = int(float(hms_to_seconds(str(audio_start_str))))
+        if audio_start_sec < 0:
+            audio_start_sec = 0
+    if audio_end_str:
+        audio_end_sec = int(float(hms_to_seconds(str(audio_end_str))))
+        if audio_end_sec < 0:
+            audio_end_sec = 0
+
+    if audio_start_sec is not None or audio_end_sec is not None:
+        if audio_start_sec is None:
+            audio_start_sec = 0
+        if audio_end_sec is not None and audio_end_sec > audio_start_sec:
+            duration_sec = audio_end_sec - audio_start_sec
+        elif duration_str:
+            tmp = int(float(hms_to_seconds(str(duration_str))))
+            duration_sec = tmp if tmp > 0 else None
+        if duration_sec is None or duration_sec <= 0:
+            return jsonify({"error": "Harap berikan rentang audio yang valid (audio_start < audio_end) atau sertakan duration"}), 400
+    else:
+        if not duration_str:
+            return jsonify({"error": "Parameter duration wajib diisi (detik atau HH:MM:SS)"}), 400
+        tmp = int(float(hms_to_seconds(str(duration_str))))
+        duration_sec = tmp if tmp > 0 else None
+        if duration_sec is None:
+            return jsonify({"error": "Duration tidak valid"}), 400
+
+    width, height = get_resolution_params(resolution)
+    if (fit in ['crop', 'pad']) and (resolution is not None) and (width is None or height is None):
+        return jsonify({"error": "Format resolution tidak valid. Gunakan preset (mis. portrait) atau WIDTHxHEIGHT"}), 400
+    width, height = normalize_even(width, height)
+
+    # Download inputs
+    try:
+        image_path = download_url_to_file(image_url, '.png')
+        audio_path = download_url_to_file(audio_url, '.mp3')
+    except Exception as e:
+        return jsonify({"error": f"Gagal download file dari URL: {str(e)}"}), 400
+
+    # Prepare output temp file
+    temp_out = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
+    temp_out.close()
+    output_path = temp_out.name
+
+    # Build FFmpeg command (same as upload variant)
+    ffmpeg_cmd = [
+        "ffmpeg", "-y",
+        "-loop", "1", "-i", image_path,
+    ]
+    if audio_start_sec is not None:
+        ffmpeg_cmd += ["-ss", str(audio_start_sec)]
+    ffmpeg_cmd += ["-i", audio_path]
+    ffmpeg_cmd += ["-r", "30"]
+    if width and height:
+        if fit == 'crop':
+            vf = f"scale={width}:{height}:force_original_aspect_ratio=increase,crop={width}:{height}"
+        else:
+            vf = f"scale={width}:{height}:force_original_aspect_ratio=decrease,pad={width}:{height}:(ow-iw)/2:(oh-ih)/2:black"
+        ffmpeg_cmd += ["-vf", vf]
+    ffmpeg_cmd += [
+        "-t", str(duration_sec),
+        "-c:v", "libx264", "-pix_fmt", "yuv420p",
+        "-c:a", "aac", "-b:a", "192k",
+        "-shortest",
+        "-movflags", "+faststart",
+        output_path
+    ]
+
+    result = run_cmd(ffmpeg_cmd)
+    # Cleanup downloads
+    try:
+        if os.path.exists(image_path):
+            os.remove(image_path)
+        if os.path.exists(audio_path):
+            os.remove(audio_path)
+    except Exception:
+        pass
+
+    if result.returncode != 0:
+        try:
+            os.remove(output_path)
+        except Exception:
+            pass
+        return jsonify({
+            "error": "Gagal membuat video dari image dan audio",
+            "details": result.stderr
+        }), 500
+
+    if not os.path.exists(output_path) or os.path.getsize(output_path) == 0:
+        try:
+            os.remove(output_path)
+        except Exception:
+            pass
+        return jsonify({"error": "File hasil kosong atau tidak ada"}), 500
+
+    from flask import send_file
+    response = send_file(output_path, as_attachment=True, download_name=f"image2video_{uuid.uuid4().hex}.mp4")
+    @response.call_on_close
+    def cleanup():
+        try:
+            os.remove(output_path)
+        except Exception:
+            pass
+    return response
+
 @app.route('/download-split', methods=['GET'])
 def download_and_split():
     """Download a full YouTube video and split it into fixed-duration parts.