app.py

import logging
import shutil
import tempfile
import subprocess
from pathlib import Path
from moviepy.editor import VideoFileClip
import gradio as gr
import requests
from urllib.parse import urlparse
import http.server
import socketserver
import threading
import atexit
import socket

logging.basicConfig(level=logging.INFO)

PORT = 8000  # Define PORT here

def get_available_port(start_port):
    while True:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            try:
                s.bind(("", start_port))
                return start_port
            except OSError as e:
                if e.errno == 98:  # errno 98 means address already in use
                    start_port += 1  # If address in use, increment port and try again
                    continue
                else:
                    raise

temp_dir = Path(tempfile.mkdtemp())  # Create a temporary directory using mkdtemp() instead of TemporaryDirectory()

class Handler(http.server.SimpleHTTPRequestHandler):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, directory=str(temp_dir), **kwargs)

def start_server():
    global PORT  # Make sure to define PORT as global
    PORT = get_available_port(PORT)
    with socketserver.TCPServer(("", PORT), Handler) as httpd:
        print(f"Serving at port {PORT}")
        httpd.serve_forever()
       
t = threading.Thread(target=start_server)
t.start()

# Cleanup function to remove the temporary directory when the script is exited
@atexit.register
def cleanup():
    shutil.rmtree(temp_dir)

logging.basicConfig(level=logging.INFO)

def download_file(url, destination):
    """Downloads a file from a url to a destination."""
    response = requests.get(url)
    response.raise_for_status()
    with open(destination, 'wb') as f:
        f.write(response.content)

def get_input_path(video_file, video_url, temp_dir):
    """Returns the path to the video file, downloading it if necessary."""
    if video_file is not None:
        return Path(video_file.name)
    elif video_url:
        url_path = urlparse(video_url).path
        file_name = Path(url_path).name
        destination = temp_dir / file_name
        download_file(video_url, destination)
        return destination
    else:
        raise ValueError("No input was provided.")

def get_output_path(input_path, temp_dir, res):
    """Returns the path to the output file, creating it if necessary."""
    output_path = temp_dir / (Path(input_path).stem + f"_{res}.m3u8")
    return output_path

def get_aspect_ratio(input_path, aspect_ratio):
    """Returns the aspect ratio of the video, calculating it if necessary."""
    if aspect_ratio is not None:
        return aspect_ratio
    video = VideoFileClip(str(input_path))
    return f"{video.size[0]}:{video.size[1]}"

def create_master_playlist(output_paths, temp_dir):
    """Creates a master playlist .m3u8 file that includes all other .m3u8 files."""
    master_playlist_path = temp_dir / "master_playlist.m3u8"
    with open(master_playlist_path, 'w') as f:
        f.write("#EXTM3U\n")
        for path in output_paths:
            f.write(f"#EXT-X-STREAM-INF:BANDWIDTH={1000*1000},RESOLUTION={path.stem.split('_')[-1]}\n")
            f.write(f"{path.name}\n")
    return master_playlist_path

def convert_video(video_file, quality, aspect_ratio, video_url):
    # Use the already-created temp_dir instead of creating a new one
    # temp_dir = Path(tempfile.mkdtemp())
    input_path = get_input_path(video_file, video_url, temp_dir)
    aspect_ratio = get_aspect_ratio(input_path, aspect_ratio)

    video = VideoFileClip(str(input_path))
    original_height = video.size[1]

    output_paths = []  # Define output_paths as an empty list

    for res in standard_resolutions:
        # Skip if resolution is higher than original
        if res > original_height:
            continue

        scale = "-1:" + str(res)  # we scale the height to res and keep aspect ratio
        output_path = get_output_path(input_path, temp_dir, str(res) + 'p')  # pass the resolution to create a unique output file

        ffmpeg_command = [
            "ffmpeg", "-i", str(input_path), "-c:v", "libx264", "-crf", str(quality),
            "-vf", f"scale={scale}:force_original_aspect_ratio=decrease,pad=ceil(iw/2)*2:ceil(ih/2)*2",
            "-hls_time", "10", "-hls_playlist_type", "vod", "-hls_segment_filename",
            str(temp_dir / f"{output_path.stem}_%03d.ts"), str(output_path)
        ]

        logging.info("Running ffmpeg command: " + ' '.join(ffmpeg_command))
        subprocess.run(ffmpeg_command, check=True)

        output_paths.append(output_path)  # Append each completed output file to the output_paths list

    master_playlist_path = create_master_playlist(output_paths, temp_dir)
    output_paths.append(master_playlist_path)

    # Convert Path objects to URLs before returning
    return format_output([{'name': path.stem, 'url': f"http://localhost:{PORT}/{path.name}"} for path in output_paths])


video_file = gr.File(label="Video File")
quality = gr.inputs.Dropdown(
    choices=["18", "23", "27", "28", "32"], 
    default="27", 
    label="Quality"
)
aspect_ratio = gr.inputs.Dropdown(
    choices=["16:9",  "1:1", "4:3", "3:2", "5:4", "21:9", "1.85:1", "2.35:1", "3:1", "360", "9:16", "2:1", "1:2", "9:1"], 
    default="16:9", 
    label="Aspect ratio (width:height)"
)
standard_resolutions = [4320, 2160, 1440, 1080, 720, 480, 360, 240, 144]  # 8K, 4K, 2K, Full HD, HD, SD in pixels
video_url = gr.Textbox(label="Or enter video URL")

def format_output(output):
    html = ""
    for file in output:
        html += f'<p><a href="{file["url"]}">{file["name"]}</a></p>'
    return html

interface = gr.Interface(
    fn=convert_video, 
    inputs=[video_file, quality, aspect_ratio, video_url],
    outputs=gr.outputs.HTML(label="Download Links"),
    title="Video Converter",
    description="A simple video converter app",
    allow_flagging=False, 
)
interface.launch()