StreamVRC.py

#!/usr/bin/env python3
"""
StreamVRC — local video server for VRChat video players.
Handles HTTP Range requests so the player can buffer and seek properly.
"""

import http.server
import os
import queue
import re
import socket
import threading
import tkinter as tk
from tkinter import filedialog, scrolledtext, ttk
from pathlib import Path

MEDIA_TYPES = {
    ".mp4":  "video/mp4",
    ".mkv":  "video/x-matroska",
    ".webm": "video/webm",
    ".avi":  "video/x-msvideo",
    ".mov":  "video/quicktime",
    ".m3u8": "application/vnd.apple.mpegurl",
    ".ts":   "video/mp2t",
}

CHUNK = 1 << 16  # 64 KB


# ---------------------------------------------------------------------------
# HTTP server
# ---------------------------------------------------------------------------

class VideoHandler(http.server.BaseHTTPRequestHandler):
    log_queue: "queue.Queue | None" = None

    def do_OPTIONS(self):
        self.send_response(200)
        self._cors()
        self.end_headers()

    def do_HEAD(self):
        self._serve(head_only=True)

    def do_GET(self):
        self._serve(head_only=False)

    def _serve(self, head_only):
        url_path = self.path.split("?")[0]
        url_path = re.sub(r"%([0-9A-Fa-f]{2})", lambda m: chr(int(m.group(1), 16)), url_path)
        fs_path = Path(os.getcwd()) / url_path.lstrip("/")

        if not fs_path.is_file():
            self.send_error(404, "File not found")
            return

        mime = MEDIA_TYPES.get(fs_path.suffix.lower(), "application/octet-stream")
        file_size = fs_path.stat().st_size
        range_header = self.headers.get("Range", "").strip()

        if range_header:
            m = re.match(r"bytes=(\d*)-(\d*)", range_header)
            if not m:
                self.send_error(400, "Invalid Range header")
                return
            start = int(m.group(1)) if m.group(1) else 0
            end   = int(m.group(2)) if m.group(2) else file_size - 1
            end   = min(end, file_size - 1)
            if start > end:
                self.send_error(416, "Range Not Satisfiable")
                return
            length = end - start + 1

            self.send_response(206)
            self.send_header("Content-Type",   mime)
            self.send_header("Content-Length", str(length))
            self.send_header("Content-Range",  f"bytes {start}-{end}/{file_size}")
            self.send_header("Accept-Ranges",  "bytes")
            self._cors()
            self.end_headers()

            if not head_only:
                with open(fs_path, "rb") as f:
                    f.seek(start)
                    remaining = length
                    while remaining > 0:
                        data = f.read(min(CHUNK, remaining))
                        if not data:
                            break
                        self.wfile.write(data)
                        remaining -= len(data)
        else:
            self.send_response(200)
            self.send_header("Content-Type",   mime)
            self.send_header("Content-Length", str(file_size))
            self.send_header("Accept-Ranges",  "bytes")
            self._cors()
            self.end_headers()

            if not head_only:
                with open(fs_path, "rb") as f:
                    while True:
                        data = f.read(CHUNK)
                        if not data:
                            break
                        self.wfile.write(data)

    def _cors(self):
        self.send_header("Access-Control-Allow-Origin",  "*")
        self.send_header("Access-Control-Allow-Headers", "Range")
        self.send_header("Access-Control-Expose-Headers",
                         "Content-Range, Accept-Ranges, Content-Length")

    def log_message(self, fmt, *args):
        if VideoHandler.log_queue is not None:
            VideoHandler.log_queue.put(f"{self.address_string()}  {fmt % args}\n")


def get_local_ip():
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(("8.8.8.8", 80))
        ip = s.getsockname()[0]
        s.close()
        return ip
    except Exception:
        return "127.0.0.1"


# ---------------------------------------------------------------------------
# GUI
# ---------------------------------------------------------------------------

class App(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("StreamVRC")
        self.minsize(580, 520)
        self.resizable(True, True)

        self._server: "http.server.HTTPServer | None" = None
        self._log_queue: queue.Queue = queue.Queue()
        VideoHandler.log_queue = self._log_queue

        self._build_ui()
        self._poll_log()
        self._dir_var.set("")
        self._refresh_files()

    def _build_ui(self):
        P = {"padx": 8, "pady": 4}

        cfg = ttk.LabelFrame(self, text="Server")
        cfg.pack(fill="x", padx=10, pady=(10, 4))

        ttk.Label(cfg, text="Directory:").grid(row=0, column=0, sticky="w", **P)
        self._dir_var = tk.StringVar()
        ttk.Entry(cfg, textvariable=self._dir_var).grid(row=0, column=1, sticky="ew", **P)
        ttk.Button(cfg, text="Browse…", command=self._browse).grid(row=0, column=2, **P)

        ttk.Label(cfg, text="Port:").grid(row=1, column=0, sticky="w", **P)
        self._port_var = tk.StringVar(value="8000")
        ttk.Entry(cfg, textvariable=self._port_var, width=8).grid(row=1, column=1, sticky="w", **P)
        cfg.columnconfigure(1, weight=1)

        btn_row = ttk.Frame(self)
        btn_row.pack(pady=6)
        self._btn_text = tk.StringVar(value="▶  Start Server")
        ttk.Button(btn_row, textvariable=self._btn_text, command=self._toggle, width=20).pack()
        self._status_lbl = ttk.Label(btn_row, text="Stopped", foreground="#888888")
        self._status_lbl.pack()

        urls = ttk.LabelFrame(self, text="URLs  (paste into VRChat video player)")
        urls.pack(fill="x", padx=10, pady=4)

        self._local_var = tk.StringVar(value="—")
        self._lan_var   = tk.StringVar(value="—")
        for row, label, var in [(0, "Local:", self._local_var), (1, "LAN:", self._lan_var)]:
            ttk.Label(urls, text=label, width=7, anchor="w").grid(row=row, column=0, **P)
            ttk.Label(urls, textvariable=var, foreground="#0055cc").grid(row=row, column=1, sticky="ew", **P)
            ttk.Button(urls, text="Copy", command=lambda v=var: self._copy(v.get())).grid(row=row, column=2, **P)
        urls.columnconfigure(1, weight=1)

        files_frame = ttk.LabelFrame(self, text="Media Files")
        files_frame.pack(fill="both", expand=True, padx=10, pady=4)

        cols = ("name", "url")
        self._tree = ttk.Treeview(files_frame, columns=cols, show="headings",
                                   selectmode="browse", height=5)
        self._tree.heading("name", text="File")
        self._tree.heading("url",  text="URL")
        self._tree.column("name", width=180, stretch=False)
        self._tree.column("url",  width=320, stretch=True)

        vsb = ttk.Scrollbar(files_frame, orient="vertical", command=self._tree.yview)
        self._tree.configure(yscrollcommand=vsb.set)
        self._tree.pack(side="left", fill="both", expand=True, padx=(4, 0), pady=4)
        vsb.pack(side="right", fill="y", pady=4, padx=(0, 4))

        ttk.Button(self, text="Copy Selected URL", command=self._copy_selected).pack(pady=(0, 4))

        log_frame = ttk.LabelFrame(self, text="Request Log")
        log_frame.pack(fill="both", expand=True, padx=10, pady=(0, 10))
        self._log = scrolledtext.ScrolledText(log_frame, height=5, state="disabled",
                                               font=("Consolas", 9), wrap="none")
        self._log.pack(fill="both", expand=True, padx=4, pady=4)

    def _browse(self):
        d = filedialog.askdirectory(initialdir=self._dir_var.get() or str(Path.home()))
        if d:
            self._dir_var.set(d)
            self._refresh_files()

    def _toggle(self):
        if self._server is None:
            self._start()
        else:
            self._stop()

    def _start(self):
        try:
            port = int(self._port_var.get())
        except ValueError:
            self._log_append("Error: invalid port number.\n")
            return
        directory = Path(self._dir_var.get())
        if not directory.is_dir():
            self._log_append(f"Error: directory not found: {directory}\n")
            return
        os.chdir(directory)
        try:
            self._server = http.server.HTTPServer(("0.0.0.0", port), VideoHandler)
        except OSError as e:
            self._log_append(f"Error: could not start server — {e}\n")
            return
        threading.Thread(target=self._server.serve_forever, daemon=True).start()
        ip = get_local_ip()
        self._local_var.set(f"http://127.0.0.1:{port}/")
        self._lan_var.set(f"http://{ip}:{port}/")
        self._btn_text.set("■  Stop Server")
        self._status_lbl.configure(text=f"Running on port {port}", foreground="#007700")
        self._log_append(f"Server started — serving {directory} on port {port}\n")
        self._refresh_files()

    def _stop(self):
        if self._server:
            self._server.shutdown()
            self._server = None
        self._local_var.set("—")
        self._lan_var.set("—")
        self._btn_text.set("▶  Start Server")
        self._status_lbl.configure(text="Stopped", foreground="#888888")
        self._log_append("Server stopped.\n")
        self._refresh_files()

    def _refresh_files(self):
        self._tree.delete(*self._tree.get_children())
        directory = Path(self._dir_var.get())
        if not directory.is_dir():
            return
        port = self._port_var.get()
        files = sorted(f for f in directory.iterdir()
                       if f.is_file() and f.suffix.lower() in MEDIA_TYPES)
        for f in files:
            self._tree.insert("", "end", values=(f.name, f"http://127.0.0.1:{port}/{f.name}"))
        if not files:
            self._tree.insert("", "end", values=("No media files found.", ""))

    def _copy(self, text: str):
        if text and text not in ("—", ""):
            self.clipboard_clear()
            self.clipboard_append(text)

    def _copy_selected(self):
        sel = self._tree.selection()
        if sel:
            url = self._tree.item(sel[0], "values")[1]
            self._copy(url)

    def _log_append(self, text: str):
        self._log.configure(state="normal")
        self._log.insert("end", text)
        self._log.see("end")
        self._log.configure(state="disabled")

    def _poll_log(self):
        try:
            while True:
                self._log_append(self._log_queue.get_nowait())
        except queue.Empty:
            pass
        self.after(200, self._poll_log)

    def destroy(self):
        if self._server:
            self._server.shutdown()
        super().destroy()


if __name__ == "__main__":
    App().mainloop()