talks-reducer 0.5.3__py3-none-any.whl → 0.6.0__py3-none-any.whl

talks_reducer/gui.py

@@ -3,15 +3,28 @@
 from __future__ import annotations
 
 import argparse
+import importlib
 import json
 import os
 import re
 import subprocess
 import sys
 import threading
+import urllib.error
+import urllib.parse
+import urllib.request
 from importlib.metadata import version
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Iterable, List, Optional, Sequence
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Iterable,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+)
 
 if TYPE_CHECKING:
     import tkinter as tk
@@ -20,6 +33,7 @@ if TYPE_CHECKING:
 try:
     from .cli import gather_input_files
     from .cli import main as cli_main
+    from .discovery import discover_servers
     from .ffmpeg import FFmpegNotFoundError
     from .models import ProcessingOptions, default_temp_folder
     from .pipeline import speed_up_video
@@ -34,6 +48,7 @@ except ImportError:  # pragma: no cover - handled at runtime
 
     from talks_reducer.cli import gather_input_files
     from talks_reducer.cli import main as cli_main
+    from talks_reducer.discovery import discover_servers
     from talks_reducer.ffmpeg import FFmpegNotFoundError
     from talks_reducer.models import ProcessingOptions, default_temp_folder
     from talks_reducer.pipeline import speed_up_video
@@ -119,6 +134,7 @@ except ModuleNotFoundError:  # pragma: no cover - runtime dependency
 
 STATUS_COLORS = {
     "idle": "#9ca3af",
+    "waiting": "#9ca3af",
     "processing": "#af8e0e",
     "success": "#178941",
     "error": "#ad4f4f",
@@ -154,6 +170,25 @@ _TRAY_LOCK = threading.Lock()
 _TRAY_PROCESS: Optional[subprocess.Popen[Any]] = None
 
 
+def _default_remote_destination(input_file: Path, *, small: bool) -> Path:
+    """Return the default remote output path for *input_file*.
+
+    Mirrors the naming scheme from the local pipeline so that remote jobs save
+    next to the source media with the expected suffix.
+    """
+
+    name = input_file.name
+    dot_index = name.rfind(".")
+    suffix = "_speedup_small" if small else "_speedup"
+
+    if dot_index != -1:
+        new_name = name[:dot_index] + suffix + name[dot_index:]
+    else:
+        new_name = name + suffix
+
+    return input_file.with_name(new_name)
+
+
 def _ensure_server_tray_running(extra_args: Optional[Sequence[str]] = None) -> None:
     """Start the server tray in a background process if one is not active."""
 
@@ -176,6 +211,31 @@ def _ensure_server_tray_running(extra_args: Optional[Sequence[str]] = None) -> N
             )
 
 
+def _parse_ratios_from_summary(summary: str) -> Tuple[Optional[float], Optional[float]]:
+    """Extract time and size ratios from a Markdown *summary* string."""
+
+    time_ratio: Optional[float] = None
+    size_ratio: Optional[float] = None
+
+    for line in summary.splitlines():
+        if "**Duration:**" in line:
+            match = re.search(r"—\s*([0-9]+(?:\.[0-9]+)?)% of the original", line)
+            if match:
+                try:
+                    time_ratio = float(match.group(1)) / 100
+                except ValueError:
+                    time_ratio = None
+        elif "**Size:**" in line:
+            match = re.search(r"\*\*Size:\*\*\s*([0-9]+(?:\.[0-9]+)?)%", line)
+            if match:
+                try:
+                    size_ratio = float(match.group(1)) / 100
+                except ValueError:
+                    size_ratio = None
+
+    return time_ratio, size_ratio
+
+
 class _GuiProgressHandle(ProgressHandle):
     """Simple progress handle that records totals but only logs milestones."""
 
@@ -240,6 +300,10 @@ class TalksReducerGUI:
     """Tkinter application mirroring the CLI options with form controls."""
 
     PADDING = 10
+    AUDIO_PROCESSING_RATIO = 0.02
+    AUDIO_PROGRESS_STEPS = 20
+    MIN_AUDIO_INTERVAL_MS = 10
+    DEFAULT_AUDIO_INTERVAL_MS = 200
 
     def _determine_config_path(self) -> Path:
         if sys.platform == "win32":
@@ -278,6 +342,21 @@ class TalksReducerGUI:
             self._settings[key] = value
         return value
 
+    def _get_float_setting(self, key: str, default: float) -> float:
+        """Return *key* as a float, coercing stored strings when necessary."""
+
+        raw_value = self._get_setting(key, default)
+        try:
+            number = float(raw_value)
+        except (TypeError, ValueError):
+            number = float(default)
+
+        if self._settings.get(key) != number:
+            self._settings[key] = number
+            self._save_settings()
+
+        return number
+
     def _update_setting(self, key: str, value: object) -> None:
         if self._settings.get(key) == value:
             return
@@ -334,6 +413,10 @@ class TalksReducerGUI:
         self._encode_target_duration_seconds: Optional[float] = None
         self._encode_total_frames: Optional[int] = None
         self._encode_current_frame: Optional[int] = None
+        self._source_duration_seconds: Optional[float] = None
+        self._audio_progress_job: Optional[str] = None
+        self._audio_progress_interval_ms: Optional[int] = None
+        self._audio_progress_steps_completed = 0
         self.progress_var = tk.IntVar(value=0)
         self._ffmpeg_process: Optional[subprocess.Popen] = None
         self._stop_requested = False
@@ -350,12 +433,26 @@ class TalksReducerGUI:
         self.open_after_convert_var = tk.BooleanVar(
             value=self._get_setting("open_after_convert", True)
         )
+        stored_mode = str(self._get_setting("processing_mode", "local"))
+        if stored_mode not in {"local", "remote"}:
+            stored_mode = "local"
+        self.processing_mode_var = tk.StringVar(value=stored_mode)
+        self.processing_mode_var.trace_add("write", self._on_processing_mode_change)
         self.theme_var = tk.StringVar(value=self._get_setting("theme", "os"))
         self.theme_var.trace_add("write", self._on_theme_change)
         self.small_var.trace_add("write", self._on_small_video_change)
         self.open_after_convert_var.trace_add(
             "write", self._on_open_after_convert_change
         )
+        self.server_url_var = tk.StringVar(
+            value=str(self._get_setting("server_url", ""))
+        )
+        self.server_url_var.trace_add("write", self._on_server_url_change)
+        self._discovery_thread: Optional[threading.Thread] = None
+
+        self._basic_defaults: dict[str, float] = {}
+        self._basic_variables: dict[str, tk.DoubleVar] = {}
+        self._slider_updaters: dict[str, Callable[[str], None]] = {}
 
         self._build_layout()
         self._apply_simple_mode(initial=True)
@@ -364,6 +461,47 @@ class TalksReducerGUI:
         self._save_settings()
         self._hide_stop_button()
 
+        # Ping server on startup if in remote mode
+        if (
+            self.processing_mode_var.get() == "remote"
+            and self.server_url_var.get().strip()
+            and hasattr(self, "_ping_server")
+        ):
+            server_url = self.server_url_var.get().strip()
+            host_label = self._format_server_host(server_url)
+
+            def ping_worker() -> None:
+                try:
+                    if self._ping_server(server_url):
+                        self._set_status("Idle", f"Server {host_label} is reachable")
+                        self._notify(
+                            lambda: self._append_log(f"Server {host_label} ready")
+                        )
+                    else:
+                        self._set_status(
+                            "Error", f"Server {host_label} is not reachable"
+                        )
+                        self._notify(
+                            lambda: self._append_log(
+                                f"Server {host_label} is not reachable"
+                            )
+                        )
+                        ping_worker()
+                except Exception as exc:
+                    self._set_status(
+                        "Idle", f"Error pinging server {host_label}: {exc}"
+                    )
+                    self._notify(
+                        lambda: self._append_log(
+                            f"Error pinging server {host_label}: {exc}"
+                        )
+                    )
+
+            import threading
+
+            ping_thread = threading.Thread(target=ping_worker, daemon=True)
+            ping_thread.start()
+
         if not self._dnd_available:
             self._append_log(
                 "Drag and drop requires the tkinterdnd2 package. Install it to enable the drop zone."
@@ -412,16 +550,8 @@ class TalksReducerGUI:
         input_frame.grid(row=0, column=0, sticky="nsew")
         main.rowconfigure(0, weight=1)
         main.columnconfigure(0, weight=1)
-        for column in range(5):
-            input_frame.columnconfigure(column, weight=1)
-
-        self.input_list = self.tk.Listbox(input_frame, height=5)
-        self.input_list.grid(row=0, column=0, columnspan=4, sticky="nsew", pady=(0, 12))
-        self.input_scrollbar = self.ttk.Scrollbar(
-            input_frame, orient=self.tk.VERTICAL, command=self.input_list.yview
-        )
-        self.input_scrollbar.grid(row=0, column=4, sticky="ns", pady=(0, 12))
-        self.input_list.configure(yscrollcommand=self.input_scrollbar.set)
+        input_frame.columnconfigure(0, weight=1)
+        input_frame.rowconfigure(0, weight=1)
 
         self.drop_zone = self.tk.Label(
             input_frame,
@@ -432,40 +562,19 @@ class TalksReducerGUI:
             pady=self.PADDING,
             highlightthickness=0,
         )
-        self.drop_zone.grid(row=1, column=0, columnspan=5, sticky="nsew")
-        input_frame.rowconfigure(1, weight=1)
+        self.drop_zone.grid(row=0, column=0, sticky="nsew")
         self._configure_drop_targets(self.drop_zone)
-        self._configure_drop_targets(self.input_list)
         self.drop_zone.configure(cursor="hand2", takefocus=1)
         self.drop_zone.bind("<Button-1>", self._on_drop_zone_click)
         self.drop_zone.bind("<Return>", self._on_drop_zone_click)
         self.drop_zone.bind("<space>", self._on_drop_zone_click)
 
-        self.add_files_button = self.ttk.Button(
-            input_frame, text="Add files", command=self._add_files
-        )
-        self.add_files_button.grid(row=2, column=0, pady=8, sticky="w")
-        self.add_folder_button = self.ttk.Button(
-            input_frame, text="Add folder", command=self._add_directory
-        )
-        self.add_folder_button.grid(row=2, column=1, pady=8)
-        self.remove_selected_button = self.ttk.Button(
-            input_frame, text="Remove selected", command=self._remove_selected
-        )
-        self.remove_selected_button.grid(row=2, column=2, pady=8, sticky="w")
-        self.run_after_drop_check = self.ttk.Checkbutton(
-            input_frame,
-            text="Run after drop",
-            variable=self.run_after_drop_var,
-        )
-        self.run_after_drop_check.grid(row=2, column=3, pady=8, sticky="e")
-
         # Options frame
-        options = self.ttk.Frame(main, padding=self.PADDING)
-        options.grid(row=2, column=0, pady=(0, 0), sticky="ew")
-        options.columnconfigure(0, weight=1)
+        self.options_frame = self.ttk.Frame(main, padding=self.PADDING)
+        self.options_frame.grid(row=2, column=0, pady=(0, 0), sticky="ew")
+        self.options_frame.columnconfigure(0, weight=1)
 
-        checkbox_frame = self.ttk.Frame(options)
+        checkbox_frame = self.ttk.Frame(self.options_frame)
         checkbox_frame.grid(row=0, column=0, columnspan=2, sticky="w")
 
         self.ttk.Checkbutton(
@@ -491,58 +600,119 @@ class TalksReducerGUI:
         )
 
         self.advanced_visible = self.tk.BooleanVar(value=False)
-        self.advanced_button = self.ttk.Button(
-            options,
-            text="Advanced",
-            command=self._toggle_advanced,
+
+        basic_label_container = self.ttk.Frame(self.options_frame)
+        basic_label = self.ttk.Label(basic_label_container, text="Basic options")
+        basic_label.pack(side=self.tk.LEFT)
+
+        self.reset_basic_button = self.ttk.Button(
+            basic_label_container,
+            text="Reset to defaults",
+            command=self._reset_basic_defaults,
+            state=self.tk.DISABLED,
         )
-        self.advanced_button.grid(row=1, column=1, sticky="e")
 
-        self.advanced_frame = self.ttk.Frame(options, padding=self.PADDING)
-        self.advanced_frame.grid(row=2, column=0, columnspan=2, sticky="nsew")
-        self.advanced_frame.columnconfigure(1, weight=1)
+        self.basic_options_frame = self.ttk.Labelframe(
+            self.options_frame, padding=0, labelwidget=basic_label_container
+        )
+        self.basic_options_frame.grid(
+            row=2, column=0, columnspan=2, sticky="ew", pady=(12, 0)
+        )
+        self.basic_options_frame.columnconfigure(1, weight=1)
 
-        self.output_var = self.tk.StringVar()
-        self._add_entry(
-            self.advanced_frame, "Output file", self.output_var, row=0, browse=True
+        self._reset_button_visible = False
+
+        self.silent_speed_var = self.tk.DoubleVar(
+            value=min(max(self._get_float_setting("silent_speed", 4.0), 1.0), 10.0)
+        )
+        self._add_slider(
+            self.basic_options_frame,
+            "Silent speed",
+            self.silent_speed_var,
+            row=0,
+            setting_key="silent_speed",
+            minimum=1.0,
+            maximum=10.0,
+            resolution=0.5,
+            display_format="{:.1f}×",
+            default_value=4.0,
         )
 
-        self.temp_var = self.tk.StringVar(value=str(default_temp_folder()))
-        self._add_entry(
-            self.advanced_frame, "Temp folder", self.temp_var, row=1, browse=True
+        self.sounded_speed_var = self.tk.DoubleVar(
+            value=min(max(self._get_float_setting("sounded_speed", 1.0), 0.75), 2.0)
+        )
+        self._add_slider(
+            self.basic_options_frame,
+            "Sounded speed",
+            self.sounded_speed_var,
+            row=1,
+            setting_key="sounded_speed",
+            minimum=0.75,
+            maximum=2.0,
+            resolution=0.25,
+            display_format="{:.2f}×",
+            default_value=1.0,
         )
 
-        self.silent_threshold_var = self.tk.StringVar()
-        self._add_entry(
-            self.advanced_frame,
+        self.silent_threshold_var = self.tk.DoubleVar(
+            value=min(max(self._get_float_setting("silent_threshold", 0.05), 0.0), 1.0)
+        )
+        self._add_slider(
+            self.basic_options_frame,
             "Silent threshold",
             self.silent_threshold_var,
             row=2,
+            setting_key="silent_threshold",
+            minimum=0.0,
+            maximum=1.0,
+            resolution=0.01,
+            display_format="{:.2f}",
+            default_value=0.05,
         )
 
-        self.sounded_speed_var = self.tk.StringVar()
-        self._add_entry(
-            self.advanced_frame, "Sounded speed", self.sounded_speed_var, row=3
+        self.ttk.Label(self.basic_options_frame, text="Server URL").grid(
+            row=3, column=0, sticky="w", pady=4
         )
-
-        self.silent_speed_var = self.tk.StringVar()
-        self._add_entry(
-            self.advanced_frame, "Silent speed", self.silent_speed_var, row=4
+        stored_server_url = str(
+            self._get_setting("server_url", "http://localhost:9005")
         )
-
-        self.frame_margin_var = self.tk.StringVar()
-        self._add_entry(
-            self.advanced_frame, "Frame margin", self.frame_margin_var, row=5
+        if not stored_server_url:
+            stored_server_url = "http://localhost:9005"
+            self._update_setting("server_url", stored_server_url)
+        self.server_url_var.set(stored_server_url)
+        self.server_url_entry = self.ttk.Entry(
+            self.basic_options_frame, textvariable=self.server_url_var, width=30
+        )
+        self.server_url_entry.grid(row=3, column=1, sticky="w", pady=4)
+        self.server_discover_button = self.ttk.Button(
+            self.basic_options_frame, text="Discover", command=self._start_discovery
         )
+        self.server_discover_button.grid(row=3, column=2, padx=(8, 0))
 
-        self.sample_rate_var = self.tk.StringVar(value="48000")
-        self._add_entry(self.advanced_frame, "Sample rate", self.sample_rate_var, row=6)
+        self.ttk.Label(self.basic_options_frame, text="Processing mode").grid(
+            row=4, column=0, sticky="w", pady=4
+        )
+        mode_choice = self.ttk.Frame(self.basic_options_frame)
+        mode_choice.grid(row=4, column=1, columnspan=2, sticky="w", pady=4)
+        self.ttk.Radiobutton(
+            mode_choice,
+            text="Local",
+            value="local",
+            variable=self.processing_mode_var,
+        ).pack(side=self.tk.LEFT, padx=(0, 8))
+        self.remote_mode_button = self.ttk.Radiobutton(
+            mode_choice,
+            text="Remote",
+            value="remote",
+            variable=self.processing_mode_var,
+        )
+        self.remote_mode_button.pack(side=self.tk.LEFT, padx=(0, 8))
 
-        self.ttk.Label(self.advanced_frame, text="Theme").grid(
-            row=7, column=0, sticky="w", pady=(8, 0)
+        self.ttk.Label(self.basic_options_frame, text="Theme").grid(
+            row=5, column=0, sticky="w", pady=(8, 0)
         )
-        theme_choice = self.ttk.Frame(self.advanced_frame)
-        theme_choice.grid(row=7, column=1, columnspan=2, sticky="w", pady=(8, 0))
+        theme_choice = self.ttk.Frame(self.basic_options_frame)
+        theme_choice.grid(row=5, column=1, columnspan=2, sticky="w", pady=(8, 0))
         for value, label in ("os", "OS"), ("light", "Light"), ("dark", "Dark"):
             self.ttk.Radiobutton(
                 theme_choice,
@@ -552,7 +722,47 @@ class TalksReducerGUI:
                 command=self._apply_theme,
             ).pack(side=self.tk.LEFT, padx=(0, 8))
 
+        self.advanced_button = self.ttk.Button(
+            self.options_frame,
+            text="Advanced",
+            command=self._toggle_advanced,
+        )
+        self.advanced_button.grid(
+            row=3, column=0, columnspan=2, sticky="w", pady=(12, 0)
+        )
+
+        self.advanced_frame = self.ttk.Frame(self.options_frame, padding=0)
+        self.advanced_frame.grid(row=4, column=0, columnspan=2, sticky="nsew")
+        self.advanced_frame.columnconfigure(1, weight=1)
+
+        self.output_var = self.tk.StringVar()
+        self._add_entry(
+            self.advanced_frame, "Output file", self.output_var, row=0, browse=True
+        )
+
+        self.temp_var = self.tk.StringVar(value=str(default_temp_folder()))
+        self._add_entry(
+            self.advanced_frame, "Temp folder", self.temp_var, row=1, browse=True
+        )
+
+        self.sample_rate_var = self.tk.StringVar(value="48000")
+        self._add_entry(self.advanced_frame, "Sample rate", self.sample_rate_var, row=2)
+
+        frame_margin_setting = self._get_setting("frame_margin", 2)
+        try:
+            frame_margin_default = int(frame_margin_setting)
+        except (TypeError, ValueError):
+            frame_margin_default = 2
+            self._update_setting("frame_margin", frame_margin_default)
+
+        self.frame_margin_var = self.tk.StringVar(value=str(frame_margin_default))
+        self._add_entry(
+            self.advanced_frame, "Frame margin", self.frame_margin_var, row=3
+        )
+
         self._toggle_advanced(initial=True)
+        self._update_processing_mode_state()
+        self._update_basic_reset_state()
 
         # Action buttons and log output
         status_frame = self.ttk.Frame(main, padding=self.PADDING)
@@ -560,6 +770,7 @@ class TalksReducerGUI:
         status_frame.columnconfigure(0, weight=0)
         status_frame.columnconfigure(1, weight=1)
         status_frame.columnconfigure(2, weight=0)
+        self.status_frame = status_frame
 
         self.ttk.Label(status_frame, text="Status:").grid(row=0, column=0, sticky="w")
         self.status_label = self.tk.Label(
@@ -644,44 +855,299 @@ class TalksReducerGUI:
             )
             button.grid(row=row, column=2, padx=(8, 0))
 
+    def _add_slider(
+        self,
+        parent,  # type: tk.Misc
+        label: str,
+        variable,  # type: tk.DoubleVar
+        *,
+        row: int,
+        setting_key: str,
+        minimum: float,
+        maximum: float,
+        resolution: float,
+        display_format: str,
+        default_value: float,
+    ) -> None:
+        self.ttk.Label(parent, text=label).grid(row=row, column=0, sticky="w", pady=4)
+
+        value_label = self.ttk.Label(parent)
+        value_label.grid(row=row, column=2, sticky="e", pady=4)
+
+        def update(value: str) -> None:
+            numeric = float(value)
+            clamped = max(minimum, min(maximum, numeric))
+            steps = round((clamped - minimum) / resolution)
+            quantized = minimum + steps * resolution
+            if abs(variable.get() - quantized) > 1e-9:
+                variable.set(quantized)
+            value_label.configure(text=display_format.format(quantized))
+            self._update_setting(setting_key, float(f"{quantized:.6f}"))
+            self._update_basic_reset_state()
+
+        slider = self.tk.Scale(
+            parent,
+            variable=variable,
+            from_=minimum,
+            to=maximum,
+            orient=self.tk.HORIZONTAL,
+            resolution=resolution,
+            showvalue=False,
+            command=update,
+            length=240,
+        )
+        slider.grid(row=row, column=1, sticky="ew", pady=4, padx=(0, 8))
+
+        update(str(variable.get()))
+
+        self._slider_updaters[setting_key] = update
+        self._basic_defaults[setting_key] = default_value
+        self._basic_variables[setting_key] = variable
+        variable.trace_add("write", lambda *_: self._update_basic_reset_state())
+
+    def _update_basic_reset_state(self) -> None:
+        """Enable or disable the reset control based on slider values."""
+
+        if not hasattr(self, "reset_basic_button"):
+            return
+
+        should_enable = False
+        for key, default_value in self._basic_defaults.items():
+            variable = self._basic_variables.get(key)
+            if variable is None:
+                continue
+            try:
+                current_value = float(variable.get())
+            except (TypeError, ValueError):
+                should_enable = True
+                break
+            if abs(current_value - default_value) > 1e-9:
+                should_enable = True
+                break
+
+        if should_enable:
+            if not getattr(self, "_reset_button_visible", False):
+                self.reset_basic_button.pack(side=self.tk.LEFT, padx=(8, 0))
+                self._reset_button_visible = True
+            self.reset_basic_button.configure(state=self.tk.NORMAL)
+        else:
+            if getattr(self, "_reset_button_visible", False):
+                self.reset_basic_button.pack_forget()
+                self._reset_button_visible = False
+            self.reset_basic_button.configure(state=self.tk.DISABLED)
+
+    def _reset_basic_defaults(self) -> None:
+        """Restore the basic numeric controls to their default values."""
+
+        for key, default_value in self._basic_defaults.items():
+            variable = self._basic_variables.get(key)
+            if variable is None:
+                continue
+
+            try:
+                current_value = float(variable.get())
+            except (TypeError, ValueError):
+                current_value = default_value
+
+            if abs(current_value - default_value) <= 1e-9:
+                continue
+
+            variable.set(default_value)
+            updater = self._slider_updaters.get(key)
+            if updater is not None:
+                updater(str(default_value))
+            else:
+                self._update_setting(key, float(f"{default_value:.6f}"))
+
+        self._update_basic_reset_state()
+
+    def _update_processing_mode_state(self) -> None:
+        has_url = bool(self.server_url_var.get().strip())
+        if not has_url and self.processing_mode_var.get() == "remote":
+            self.processing_mode_var.set("local")
+            return
+
+        if hasattr(self, "remote_mode_button"):
+            state = self.tk.NORMAL if has_url else self.tk.DISABLED
+            self.remote_mode_button.configure(state=state)
+
+    def _normalize_server_url(self, server_url: str) -> str:
+        parsed = urllib.parse.urlsplit(server_url)
+        if not parsed.scheme:
+            parsed = urllib.parse.urlsplit(f"http://{server_url}")
+
+        netloc = parsed.netloc or parsed.path
+        if not netloc:
+            return server_url
+
+        path = parsed.path if parsed.netloc else ""
+        normalized_path = path or "/"
+        return urllib.parse.urlunsplit((parsed.scheme, netloc, normalized_path, "", ""))
+
+    def _format_server_host(self, server_url: str) -> str:
+        parsed = urllib.parse.urlsplit(server_url)
+        if not parsed.scheme:
+            parsed = urllib.parse.urlsplit(f"http://{server_url}")
+
+        host = parsed.netloc or parsed.path or server_url
+        if parsed.netloc and parsed.path and parsed.path not in {"", "/"}:
+            host = f"{parsed.netloc}{parsed.path}"
+
+        host = host.rstrip("/").split(":")[0]
+        return host or server_url
+
+    def _ping_server(self, server_url: str, *, timeout: float = 5.0) -> bool:
+        normalized = self._normalize_server_url(server_url)
+        request = urllib.request.Request(
+            normalized,
+            headers={"User-Agent": "talks-reducer-gui"},
+            method="GET",
+        )
+
+        try:
+            with urllib.request.urlopen(request, timeout=timeout) as response:
+                status = getattr(response, "status", None)
+                if status is None:
+                    status = response.getcode()
+                if status is None:
+                    return False
+                return 200 <= int(status) < 500
+        except (urllib.error.URLError, ValueError):
+            return False
+
+    def _start_discovery(self) -> None:
+        """Search the local network for running Talks Reducer servers."""
+
+        if self._discovery_thread and self._discovery_thread.is_alive():
+            return
+
+        self.server_discover_button.configure(
+            state=self.tk.DISABLED, text="Discovering…"
+        )
+        self._append_log("Discovering Talks Reducer servers on port 9005…")
+
+        def worker() -> None:
+            try:
+                urls = discover_servers(
+                    progress_callback=lambda current, total: self._notify(
+                        lambda c=current, t=total: self._on_discovery_progress(c, t)
+                    )
+                )
+            except Exception as exc:  # pragma: no cover - network failure safeguard
+                self._notify(lambda: self._on_discovery_failed(exc))
+                return
+            self._notify(lambda: self._on_discovery_complete(urls))
+
+        self._discovery_thread = threading.Thread(target=worker, daemon=True)
+        self._discovery_thread.start()
+
+    def _on_discovery_failed(self, exc: Exception) -> None:
+        self.server_discover_button.configure(state=self.tk.NORMAL, text="Discover")
+        message = f"Discovery failed: {exc}"
+        self._append_log(message)
+        self.messagebox.showerror("Discovery failed", message)
+
+    def _on_discovery_progress(self, current: int, total: int) -> None:
+        if total > 0:
+            bounded = max(0, min(current, total))
+            label = f"{bounded} / {total}"
+        else:
+            label = "Discovering…"
+        self.server_discover_button.configure(text=label)
+
+    def _on_discovery_complete(self, urls: List[str]) -> None:
+        self.server_discover_button.configure(state=self.tk.NORMAL, text="Discover")
+        if not urls:
+            self._append_log("No Talks Reducer servers were found.")
+            self.messagebox.showinfo(
+                "No servers found",
+                "No Talks Reducer servers responded on port 9005.",
+            )
+            return
+
+        self._append_log(
+            f"Discovered {len(urls)} server{'s' if len(urls) != 1 else ''}."
+        )
+
+        if len(urls) == 1:
+            self.server_url_var.set(urls[0])
+            return
+
+        self._show_discovery_results(urls)
+
+    def _show_discovery_results(self, urls: List[str]) -> None:
+        dialog = self.tk.Toplevel(self.root)
+        dialog.title("Select server")
+        dialog.transient(self.root)
+        dialog.grab_set()
+
+        self.ttk.Label(dialog, text="Select a Talks Reducer server:").grid(
+            row=0, column=0, columnspan=2, sticky="w", padx=self.PADDING, pady=(12, 4)
+        )
+
+        listbox = self.tk.Listbox(
+            dialog,
+            height=min(10, len(urls)),
+            selectmode=self.tk.SINGLE,
+        )
+        listbox.grid(
+            row=1,
+            column=0,
+            columnspan=2,
+            padx=self.PADDING,
+            sticky="nsew",
+        )
+        dialog.columnconfigure(0, weight=1)
+        dialog.columnconfigure(1, weight=1)
+        dialog.rowconfigure(1, weight=1)
+
+        for url in urls:
+            listbox.insert(self.tk.END, url)
+        listbox.select_set(0)
+
+        def choose(_: object | None = None) -> None:
+            selection = listbox.curselection()
+            if not selection:
+                return
+            index = selection[0]
+            self.server_url_var.set(urls[index])
+            dialog.grab_release()
+            dialog.destroy()
+
+        def cancel() -> None:
+            dialog.grab_release()
+            dialog.destroy()
+
+        listbox.bind("<Double-Button-1>", choose)
+        listbox.bind("<Return>", choose)
+
+        button_frame = self.ttk.Frame(dialog)
+        button_frame.grid(row=2, column=0, columnspan=2, pady=(8, 12))
+        self.ttk.Button(button_frame, text="Use server", command=choose).pack(
+            side=self.tk.LEFT, padx=(0, 8)
+        )
+        self.ttk.Button(button_frame, text="Cancel", command=cancel).pack(
+            side=self.tk.LEFT
+        )
+        dialog.protocol("WM_DELETE_WINDOW", cancel)
+
     def _toggle_simple_mode(self) -> None:
         self._update_setting("simple_mode", self.simple_mode_var.get())
         self._apply_simple_mode()
 
     def _apply_simple_mode(self, *, initial: bool = False) -> None:
         simple = self.simple_mode_var.get()
-        widgets = [
-            self.input_list,
-            self.input_scrollbar,
-            self.add_files_button,
-            self.add_folder_button,
-            self.remove_selected_button,
-            self.run_after_drop_check,
-        ]
-
         if simple:
-            for widget in widgets:
-                widget.grid_remove()
+            self.basic_options_frame.grid_remove()
             self.log_frame.grid_remove()
             self.stop_button.grid_remove()
             self.advanced_button.grid_remove()
             self.advanced_frame.grid_remove()
-            if hasattr(self, "status_frame"):
-                self.status_frame.grid_remove()
             self.run_after_drop_var.set(True)
             self._apply_window_size(simple=True)
-            if self.status_var.get().lower() == "success" and hasattr(
-                self, "status_frame"
-            ):
-                self.status_frame.grid()
-                self.open_button.grid()
-                self.drop_hint_button.grid_remove()
         else:
-            for widget in widgets:
-                widget.grid()
+            self.basic_options_frame.grid()
             self.log_frame.grid()
-            if hasattr(self, "status_frame"):
-                self.status_frame.grid()
             self.advanced_button.grid()
             if self.advanced_visible.get():
                 self.advanced_frame.grid()
@@ -726,6 +1192,19 @@ class TalksReducerGUI:
             "open_after_convert", bool(self.open_after_convert_var.get())
         )
 
+    def _on_processing_mode_change(self, *_: object) -> None:
+        value = self.processing_mode_var.get()
+        if value not in {"local", "remote"}:
+            self.processing_mode_var.set("local")
+            return
+        self._update_setting("processing_mode", value)
+        self._update_processing_mode_state()
+
+    def _on_server_url_change(self, *_: object) -> None:
+        value = self.server_url_var.get().strip()
+        self._update_setting("server_url", value)
+        self._update_processing_mode_state()
+
     def _apply_theme(self) -> None:
         preference = self.theme_var.get().lower()
         if preference not in {"light", "dark"}:
@@ -844,14 +1323,6 @@ class TalksReducerGUI:
             fg=palette["foreground"],
             highlightthickness=0,
         )
-        self.input_list.configure(
-            bg=palette["surface"],
-            fg=palette["foreground"],
-            selectbackground=palette.get("selection_background", palette["accent"]),
-            selectforeground=palette.get("selection_foreground", palette["surface"]),
-            highlightbackground=palette["border"],
-            highlightcolor=palette["border"],
-        )
         self.log_text.configure(
             bg=palette["surface"],
             fg=palette["foreground"],
@@ -913,7 +1384,6 @@ class TalksReducerGUI:
             resolved = os.fspath(Path(path))
             if resolved not in self.input_files:
                 self.input_files.append(resolved)
-                self.input_list.insert(self.tk.END, resolved)
                 normalized.append(resolved)
 
         if auto_run and normalized:
@@ -947,21 +1417,13 @@ class TalksReducerGUI:
         for path in paths:
             if path and path not in self.input_files:
                 self.input_files.append(path)
-                self.input_list.insert(self.tk.END, path)
                 added = True
         if auto_run and added and self.run_after_drop_var.get():
             self._start_run()
 
-    def _remove_selected(self) -> None:
-        selection = list(self.input_list.curselection())
-        for index in reversed(selection):
-            self.input_list.delete(index)
-            del self.input_files[index]
-
     def _clear_input_files(self) -> None:
-        """Clear all input files from the list."""
+        """Clear all queued input files."""
         self.input_files.clear()
-        self.input_list.delete(0, self.tk.END)
 
     def _on_drop(self, event: object) -> None:
         data = getattr(event, "data", "")
@@ -971,7 +1433,6 @@ class TalksReducerGUI:
         cleaned = [path.strip("{}") for path in paths]
         # Clear existing files before adding dropped files
         self.input_files.clear()
-        self.input_list.delete(0, self.tk.END)
         self._extend_inputs(cleaned, auto_run=True)
 
     def _on_drop_zone_click(self, event: object) -> str | None:
@@ -1017,14 +1478,19 @@ class TalksReducerGUI:
         self._append_log("Starting processing…")
         self._stop_requested = False
         open_after_convert = bool(self.open_after_convert_var.get())
+        server_url = self.server_url_var.get().strip()
+        remote_mode = self.processing_mode_var.get() == "remote"
+        if remote_mode and not server_url:
+            self.messagebox.showerror(
+                "Missing server URL", "Remote mode requires a server URL."
+            )
+            return
+        remote_mode = remote_mode and bool(server_url)
 
         def worker() -> None:
             def set_process(proc: subprocess.Popen) -> None:
                 self._ffmpeg_process = proc
 
-            reporter = _TkProgressReporter(
-                self._append_log, process_callback=set_process
-            )
             try:
                 files = gather_input_files(self.input_files)
                 if not files:
@@ -1036,6 +1502,20 @@ class TalksReducerGUI:
                     self._set_status("Idle")
                     return
 
+                if remote_mode:
+                    success = self._process_files_via_server(
+                        files,
+                        args,
+                        server_url,
+                        open_after_convert=open_after_convert,
+                    )
+                    if success:
+                        self._notify(self._hide_stop_button)
+                    return
+
+                reporter = _TkProgressReporter(
+                    self._append_log, process_callback=set_process
+                )
                 for index, file in enumerate(files, start=1):
                     self._append_log(
                         f"Processing {index}/{len(files)}: {os.path.basename(file)}"
@@ -1085,7 +1565,10 @@ class TalksReducerGUI:
         self._processing_thread.start()
 
         # Show Stop button when processing starts
-        self.stop_button.grid()
+        if remote_mode:
+            self.stop_button.grid_remove()
+        else:
+            self.stop_button.grid()
 
     def _stop_processing(self) -> None:
         """Stop the currently running processing by terminating FFmpeg."""
@@ -1129,18 +1612,14 @@ class TalksReducerGUI:
             args["output_file"] = Path(self.output_var.get())
         if self.temp_var.get():
             args["temp_folder"] = Path(self.temp_var.get())
-        if self.silent_threshold_var.get():
-            args["silent_threshold"] = self._parse_float(
-                self.silent_threshold_var.get(), "Silent threshold"
-            )
-        if self.sounded_speed_var.get():
-            args["sounded_speed"] = self._parse_float(
-                self.sounded_speed_var.get(), "Sounded speed"
-            )
-        if self.silent_speed_var.get():
-            args["silent_speed"] = self._parse_float(
-                self.silent_speed_var.get(), "Silent speed"
-            )
+        silent_threshold = float(self.silent_threshold_var.get())
+        args["silent_threshold"] = round(silent_threshold, 2)
+
+        sounded_speed = float(self.sounded_speed_var.get())
+        args["sounded_speed"] = round(sounded_speed, 2)
+
+        silent_speed = float(self.silent_speed_var.get())
+        args["silent_speed"] = round(silent_speed, 2)
         if self.frame_margin_var.get():
             args["frame_spreadage"] = int(
                 round(self._parse_float(self.frame_margin_var.get(), "Frame margin"))
@@ -1153,6 +1632,112 @@ class TalksReducerGUI:
             args["small"] = True
         return args
 
+    def _process_files_via_server(
+        self,
+        files: List[str],
+        args: dict[str, object],
+        server_url: str,
+        *,
+        open_after_convert: bool,
+    ) -> bool:
+        """Send *files* to the configured server for processing."""
+
+        try:
+            service_module = importlib.import_module("talks_reducer.service_client")
+        except ModuleNotFoundError as exc:
+            self._append_log(f"Server client unavailable: {exc}")
+            self._notify(
+                lambda: self.messagebox.showerror(
+                    "Server unavailable",
+                    "Remote processing requires the gradio_client package.",
+                )
+            )
+            self._notify(lambda: self._set_status("Error"))
+            return False
+
+        host_label = self._format_server_host(server_url)
+        self._notify(
+            lambda: self._set_status("waiting", f"Waiting server {host_label}...")
+        )
+        if not self._ping_server(server_url):
+            self._append_log(f"Server unreachable: {server_url}")
+            self._notify(
+                lambda: self._set_status("Error", f"Server {host_label} unreachable")
+            )
+            return False
+
+        self._notify(lambda: self._set_status("waiting", f"Server {host_label} ready"))
+
+        output_override = args.get("output_file") if len(files) == 1 else None
+        ignored = [key for key in args if key not in {"output_file", "small"}]
+        if ignored:
+            ignored_options = ", ".join(sorted(ignored))
+            self._append_log(
+                f"Server mode ignores the following options: {ignored_options}"
+            )
+
+        small_mode = bool(args.get("small", False))
+
+        for index, file in enumerate(files, start=1):
+            basename = os.path.basename(file)
+            self._append_log(
+                f"Uploading {index}/{len(files)}: {basename} to {server_url}"
+            )
+            input_path = Path(file)
+
+            if output_override is not None:
+                output_path = Path(output_override)
+                if output_path.is_dir():
+                    output_path = (
+                        output_path
+                        / _default_remote_destination(input_path, small=small_mode).name
+                    )
+            else:
+                output_path = _default_remote_destination(input_path, small=small_mode)
+
+            try:
+                destination, summary, log_text = service_module.send_video(
+                    input_path=input_path,
+                    output_path=output_path,
+                    server_url=server_url,
+                    small=small_mode,
+                    stream_updates=True,
+                    log_callback=self._append_log,
+                    # progress_callback=self._handle_service_progress,
+                )
+            except Exception as exc:  # pragma: no cover - network safeguard
+                error_detail = f"{exc.__class__.__name__}: {exc}"
+                error_msg = f"Processing failed: {error_detail}"
+                self._append_log(error_msg)
+                self._notify(lambda: self._set_status("Error"))
+                self._notify(
+                    lambda: self.messagebox.showerror(
+                        "Server error",
+                        f"Failed to process {basename}: {error_detail}",
+                    )
+                )
+                return False
+
+            self._last_output = Path(destination)
+            time_ratio, size_ratio = _parse_ratios_from_summary(summary)
+            self._last_time_ratio = time_ratio
+            self._last_size_ratio = size_ratio
+            for line in summary.splitlines():
+                self._append_log(line)
+            if log_text.strip():
+                self._append_log("Server log:")
+                for line in log_text.splitlines():
+                    self._append_log(line)
+            if open_after_convert:
+                self._notify(
+                    lambda path=self._last_output: self._open_in_file_manager(path)
+                )
+
+        self._append_log("All jobs finished successfully.")
+        self._notify(lambda: self.open_button.configure(state=self.tk.NORMAL))
+        self._notify(self._clear_input_files)
+        return True
+
     def _parse_float(self, value: str, label: str) -> float:
         try:
             return float(value)
@@ -1203,12 +1788,23 @@ class TalksReducerGUI:
 
     def _update_status_from_message(self, message: str) -> None:
         normalized = message.strip().lower()
+        metadata_match = re.search(
+            r"source metadata [—-] duration:\s*([\d.]+)s",
+            message,
+            re.IGNORECASE,
+        )
+        if metadata_match:
+            try:
+                self._source_duration_seconds = float(metadata_match.group(1))
+            except ValueError:
+                self._source_duration_seconds = None
         if "all jobs finished successfully" in normalized:
             # Create status message with ratios if available
             status_msg = "Success"
             if self._last_time_ratio is not None and self._last_size_ratio is not None:
                 status_msg = f"Time: {self._last_time_ratio:.0%}, Size: {self._last_size_ratio:.0%}"
 
+            self._reset_audio_progress_state(clear_source=True)
             self._set_status("success", status_msg)
             self._set_progress(100)  # 100% on success
             self._video_duration_seconds = None  # Reset for next video
@@ -1216,21 +1812,36 @@ class TalksReducerGUI:
             self._encode_total_frames = None
             self._encode_current_frame = None
         elif normalized.startswith("extracting audio"):
+            self._reset_audio_progress_state(clear_source=False)
             self._set_status("processing", "Extracting audio...")
             self._set_progress(0)  # 0% on start
             self._video_duration_seconds = None  # Reset for new processing
             self._encode_target_duration_seconds = None
             self._encode_total_frames = None
             self._encode_current_frame = None
-        elif normalized.startswith("starting processing") or normalized.startswith(
-            "processing"
-        ):
+            self._start_audio_progress()
+        elif normalized.startswith("uploading"):
+            self._set_status("processing", "Uploading...")
+        elif normalized.startswith("starting processing"):
+            self._reset_audio_progress_state(clear_source=True)
             self._set_status("processing", "Processing")
             self._set_progress(0)  # 0% on start
             self._video_duration_seconds = None  # Reset for new processing
             self._encode_target_duration_seconds = None
             self._encode_total_frames = None
             self._encode_current_frame = None
+        elif normalized.startswith("processing"):
+            is_new_job = bool(re.match(r"processing \d+/\d+:", normalized))
+            should_reset = self._status_state.lower() != "processing" or is_new_job
+            if should_reset:
+                self._set_progress(0)  # 0% on start
+                self._video_duration_seconds = None  # Reset for new processing
+                self._encode_target_duration_seconds = None
+                self._encode_total_frames = None
+                self._encode_current_frame = None
+            if is_new_job:
+                self._reset_audio_progress_state(clear_source=True)
+            self._set_status("processing", "Processing")
 
         frame_total_match = re.search(
             r"Final encode target frames(?: \(fallback\))?:\s*(\d+)", message
@@ -1256,12 +1867,12 @@ class TalksReducerGUI:
 
                 self._encode_current_frame = current_frame
                 if self._encode_total_frames and self._encode_total_frames > 0:
-                    percentage = min(
-                        100,
-                        int((current_frame / self._encode_total_frames) * 100),
-                    )
+                    self._complete_audio_phase()
+                    frame_ratio = min(current_frame / self._encode_total_frames, 1.0)
+                    percentage = min(100, 5 + int(frame_ratio * 95))
                     self._set_progress(percentage)
                 else:
+                    self._complete_audio_phase()
                     self._set_status("processing", f"{current_frame} frames encoded")
 
         # Parse encode target duration reported by the pipeline
@@ -1320,11 +1931,95 @@ class TalksReducerGUI:
                 and total_seconds
                 and total_seconds > 0
             ):
-                percentage = min(100, int((current_seconds / total_seconds) * 100))
+                self._complete_audio_phase()
+                time_ratio = min(current_seconds / total_seconds, 1.0)
+                percentage = min(100, 5 + int(time_ratio * 95))
                 self._set_progress(percentage)
 
             self._set_status("processing", status_msg)
 
+    def _compute_audio_progress_interval(self) -> int:
+        duration = self._source_duration_seconds or self._video_duration_seconds
+        if duration and duration > 0:
+            audio_seconds = max(duration * self.AUDIO_PROCESSING_RATIO, 0.0)
+            interval_seconds = audio_seconds / self.AUDIO_PROGRESS_STEPS
+            interval_ms = int(round(interval_seconds * 1000))
+            return max(self.MIN_AUDIO_INTERVAL_MS, interval_ms)
+        return self.DEFAULT_AUDIO_INTERVAL_MS
+
+    def _start_audio_progress(self) -> None:
+        interval_ms = self._compute_audio_progress_interval()
+
+        def _start() -> None:
+            if self._audio_progress_job is not None:
+                self.root.after_cancel(self._audio_progress_job)
+            self._audio_progress_steps_completed = 0
+            self._audio_progress_interval_ms = interval_ms
+            self._audio_progress_job = self.root.after(
+                interval_ms, self._advance_audio_progress
+            )
+
+        self._notify(_start)
+
+    def _advance_audio_progress(self) -> None:
+        self._audio_progress_job = None
+        if self._audio_progress_steps_completed >= self.AUDIO_PROGRESS_STEPS:
+            self._audio_progress_interval_ms = None
+            return
+
+        self._audio_progress_steps_completed += 1
+        audio_percentage = (
+            self._audio_progress_steps_completed / self.AUDIO_PROGRESS_STEPS * 100
+        )
+        percentage = (audio_percentage / 100) * 5
+        self._set_progress(percentage)
+        self._set_status("processing", "Audio processing: %d%%" % (audio_percentage))
+
+        if self._audio_progress_steps_completed < self.AUDIO_PROGRESS_STEPS:
+            interval_ms = (
+                self._audio_progress_interval_ms or self.DEFAULT_AUDIO_INTERVAL_MS
+            )
+            self._audio_progress_job = self.root.after(
+                interval_ms, self._advance_audio_progress
+            )
+        else:
+            self._audio_progress_interval_ms = None
+
+    def _cancel_audio_progress(self) -> None:
+        if self._audio_progress_job is None:
+            self._audio_progress_interval_ms = None
+            return
+
+        def _cancel() -> None:
+            if self._audio_progress_job is not None:
+                self.root.after_cancel(self._audio_progress_job)
+                self._audio_progress_job = None
+            self._audio_progress_interval_ms = None
+
+        self._notify(_cancel)
+
+    def _reset_audio_progress_state(self, *, clear_source: bool) -> None:
+        if clear_source:
+            self._source_duration_seconds = None
+        self._audio_progress_steps_completed = 0
+        self._audio_progress_interval_ms = None
+        if self._audio_progress_job is not None:
+            self._cancel_audio_progress()
+
+    def _complete_audio_phase(self) -> None:
+        def _complete() -> None:
+            if self._audio_progress_job is not None:
+                self.root.after_cancel(self._audio_progress_job)
+                self._audio_progress_job = None
+            self._audio_progress_interval_ms = None
+            if self._audio_progress_steps_completed < self.AUDIO_PROGRESS_STEPS:
+                self._audio_progress_steps_completed = self.AUDIO_PROGRESS_STEPS
+                current_value = self.progress_var.get()
+                if current_value < self.AUDIO_PROGRESS_STEPS:
+                    self._set_progress(self.AUDIO_PROGRESS_STEPS)
+
+        self._notify(_complete)
+
     def _apply_status_style(self, status: str) -> None:
         color = STATUS_COLORS.get(status.lower())
         if color:
@@ -1363,6 +2058,8 @@ class TalksReducerGUI:
                     self.status_frame.grid()
                 self.stop_button.grid()
                 self.drop_hint_button.grid_remove()
+            else:
+                self._reset_audio_progress_state(clear_source=True)
 
             if lowered == "success" or "time:" in lowered and "size:" in lowered:
                 if self.simple_mode_var.get() and hasattr(self, "status_frame"):
@@ -1375,12 +2072,7 @@ class TalksReducerGUI:
             else:
                 self.open_button.grid_remove()
                 # print("not success status")
-                if (
-                    self.simple_mode_var.get()
-                    and not is_processing
-                    and hasattr(self, "status_frame")
-                ):
-                    self.status_frame.grid_remove()
+                if self.simple_mode_var.get() and not is_processing:
                     self.stop_button.grid_remove()
                     # Show drop hint when no other buttons are visible
                     if hasattr(self, "drop_hint_button"):
@@ -1526,9 +2218,20 @@ def main(argv: Optional[Sequence[str]] = None) -> bool:
         action="store_true",
         help="Do not start the Talks Reducer server tray alongside the GUI.",
     )
+    parser.add_argument(
+        "--server",
+        action="store_true",
+        help="Launch the Talks Reducer server tray instead of the desktop GUI.",
+    )
 
     parsed_args, remaining = parser.parse_known_args(argv)
     no_tray = parsed_args.no_tray
+    if parsed_args.server:
+        package_name = __package__ or "talks_reducer"
+        tray_module = importlib.import_module(f"{package_name}.server_tray")
+        tray_main = getattr(tray_module, "main")
+        tray_main(remaining)
+        return False
     argv = remaining
 
     if argv: