update

app.py

@@ -3,8 +3,6 @@ import subprocess
 import os
 import uuid
 import tempfile
-import urllib.request
-import urllib.parse
 
 app = Flask(__name__)
 
@@ -97,64 +95,6 @@ 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.
@@ -299,146 +239,6 @@ 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.