talks-reducer 0.1.0__tar.gz

talks_reducer-0.1.0/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2019 carykh
+Copyright (c) 2020 gegell
+Copyright (c) 2025 Stanislav Popov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

talks_reducer-0.1.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: talks-reducer
+Version: 0.1.0
+Summary: CLI for speeding up long-form talks by removing silence
+Author: Talks Reducer Maintainers
+License: MIT License
+        
+        Copyright (c) 2019 carykh
+        Copyright (c) 2020 gegell
+        Copyright (c) 2025 Stanislav Popov
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: audiotsm>=0.1.2
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: numpy<2.0.0,>=1.22.0
+Requires-Dist: tqdm>=4.65.0
+Dynamic: license-file
+
+# Talks Reducer
+Talks Reducer shortens long-form presentations by removing silent gaps and optionally re-encoding them to smaller files. The
+project was renamed from **jumpcutter** to emphasize its focus on conference talks and lectures.
+
+When CUDA-capable hardware is available the pipeline leans on GPU encoders to keep export times low, but it still runs great on
+CPUs.
+
+## Repository Structure
+- `talks_reducer/` — Python package that exposes the CLI and reusable pipeline:
+  - `cli.py` parses arguments and dispatches to the pipeline.
+  - `pipeline.py` orchestrates FFmpeg, audio processing, and temporary assets.
+  - `audio.py` handles audio validation, volume analysis, and phase vocoder processing.
+  - `chunks.py` builds timing metadata and FFmpeg expressions for frame selection.
+  - `ffmpeg.py` discovers the FFmpeg binary, checks CUDA availability, and assembles command strings.
+- `requirements.txt` — Python dependencies for local development.
+- `default.nix` — reproducible environment definition for Nix users.
+- `CONTRIBUTION.md` — development workflow, formatting expectations, and release checklist.
+- `AGENTS.md` — maintainer tips and coding conventions for this repository.
+
+## Example
+- 1h 37m, 571 MB — Original OBS video
+- 1h 19m, 751 MB — Talks Reducer
+- 1h 19m, 171 MB — Talks Reducer `--small`
+
+The `--small` preset applies a 720p video scale and 128 kbps audio bitrate, making it useful for sharing talks over constrained
+connections. Without `--small`, the script aims to preserve original quality while removing silence.
+
+## Highlights
+- Builds on gegell's classic jumpcutter workflow with more efficient frame and audio processing
+- Generates FFmpeg filter graphs instead of writing temporary frames to disk
+- Streams audio transformations in memory to avoid slow intermediate files
+- Accepts multiple inputs or directories of recordings in a single run
+- Provides progress feedback via `tqdm`
+- Automatically detects NVENC availability, so you no longer need to pass `--cuda`
+
+## Processing Pipeline
+1. Validate that each input file contains an audio stream using `ffprobe`.
+2. Extract audio and calculate loudness to identify silent regions.
+3. Stretch the non-silent segments with `audiotsm` to maintain speech clarity.
+4. Stitch the processed audio and video together with FFmpeg, using NVENC if the GPU encoders are detected.
+
+## Recent Updates
+- **October 2025** — Project renamed to *Talks Reducer* across documentation and scripts.
+- **October 2025** — Added `--small` preset with 720p/128 kbps defaults for bandwidth-friendly exports.
+- **October 2025** — Removed the `--cuda` flag; CUDA/NVENC support is now auto-detected.
+- **October 2025** — Improved `--small` encoder arguments to balance size and clarity.
+- **October 2025** — CLI argument parsing fixes to prevent crashes on invalid combinations.
+- **October 2025** — Added example output comparison to the README.
+
+## Quick Start
+1. Install FFmpeg and ensure it is on your `PATH`
+2. Install Talks Reducer with `pip install talks-reducer` (this exposes the `talks-reducer` command)
+3. Inspect available options with `talks-reducer --help`
+4. Process a recording using `talks-reducer /path/to/video`
+
+## Requirements
+- Python 3 with `numpy`, `scipy`, `audiotsm`, and `tqdm`
+- FFmpeg with optional NVIDIA NVENC support for CUDA acceleration
+
+## Contributing
+See `CONTRIBUTION.md` for development setup details and guidance on sharing improvements.
+
+## License
+Talks Reducer is released under the MIT License. See `LICENSE` for the full text.

talks_reducer-0.1.0/README.md

@@ -0,0 +1,64 @@
+# Talks Reducer
+Talks Reducer shortens long-form presentations by removing silent gaps and optionally re-encoding them to smaller files. The
+project was renamed from **jumpcutter** to emphasize its focus on conference talks and lectures.
+
+When CUDA-capable hardware is available the pipeline leans on GPU encoders to keep export times low, but it still runs great on
+CPUs.
+
+## Repository Structure
+- `talks_reducer/` — Python package that exposes the CLI and reusable pipeline:
+  - `cli.py` parses arguments and dispatches to the pipeline.
+  - `pipeline.py` orchestrates FFmpeg, audio processing, and temporary assets.
+  - `audio.py` handles audio validation, volume analysis, and phase vocoder processing.
+  - `chunks.py` builds timing metadata and FFmpeg expressions for frame selection.
+  - `ffmpeg.py` discovers the FFmpeg binary, checks CUDA availability, and assembles command strings.
+- `requirements.txt` — Python dependencies for local development.
+- `default.nix` — reproducible environment definition for Nix users.
+- `CONTRIBUTION.md` — development workflow, formatting expectations, and release checklist.
+- `AGENTS.md` — maintainer tips and coding conventions for this repository.
+
+## Example
+- 1h 37m, 571 MB — Original OBS video
+- 1h 19m, 751 MB — Talks Reducer
+- 1h 19m, 171 MB — Talks Reducer `--small`
+
+The `--small` preset applies a 720p video scale and 128 kbps audio bitrate, making it useful for sharing talks over constrained
+connections. Without `--small`, the script aims to preserve original quality while removing silence.
+
+## Highlights
+- Builds on gegell's classic jumpcutter workflow with more efficient frame and audio processing
+- Generates FFmpeg filter graphs instead of writing temporary frames to disk
+- Streams audio transformations in memory to avoid slow intermediate files
+- Accepts multiple inputs or directories of recordings in a single run
+- Provides progress feedback via `tqdm`
+- Automatically detects NVENC availability, so you no longer need to pass `--cuda`
+
+## Processing Pipeline
+1. Validate that each input file contains an audio stream using `ffprobe`.
+2. Extract audio and calculate loudness to identify silent regions.
+3. Stretch the non-silent segments with `audiotsm` to maintain speech clarity.
+4. Stitch the processed audio and video together with FFmpeg, using NVENC if the GPU encoders are detected.
+
+## Recent Updates
+- **October 2025** — Project renamed to *Talks Reducer* across documentation and scripts.
+- **October 2025** — Added `--small` preset with 720p/128 kbps defaults for bandwidth-friendly exports.
+- **October 2025** — Removed the `--cuda` flag; CUDA/NVENC support is now auto-detected.
+- **October 2025** — Improved `--small` encoder arguments to balance size and clarity.
+- **October 2025** — CLI argument parsing fixes to prevent crashes on invalid combinations.
+- **October 2025** — Added example output comparison to the README.
+
+## Quick Start
+1. Install FFmpeg and ensure it is on your `PATH`
+2. Install Talks Reducer with `pip install talks-reducer` (this exposes the `talks-reducer` command)
+3. Inspect available options with `talks-reducer --help`
+4. Process a recording using `talks-reducer /path/to/video`
+
+## Requirements
+- Python 3 with `numpy`, `scipy`, `audiotsm`, and `tqdm`
+- FFmpeg with optional NVIDIA NVENC support for CUDA acceleration
+
+## Contributing
+See `CONTRIBUTION.md` for development setup details and guidance on sharing improvements.
+
+## License
+Talks Reducer is released under the MIT License. See `LICENSE` for the full text.

talks_reducer-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "talks-reducer"
+version = "0.1.0"
+description = "CLI for speeding up long-form talks by removing silence"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { file = "LICENSE" }
+authors = [
+    { name = "Talks Reducer Maintainers" }
+]
+dependencies = [
+    "audiotsm>=0.1.2",
+    "scipy>=1.10.0",
+    "numpy>=1.22.0,<2.0.0",
+    "tqdm>=4.65.0",
+]
+
+[project.scripts]
+talks-reducer = "talks_reducer.cli:main"
+
+[tool.black]
+line-length = 88
+target-version = ["py39"]
+
+[tool.isort]
+profile = "black"
+line_length = 88
+known_first_party = ["talks_reducer"]
+

talks_reducer-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

talks_reducer-0.1.0/talks_reducer/__init__.py

@@ -0,0 +1,7 @@
+"""talks_reducer exposes a CLI for speeding up videos with silent sections."""
+
+from __future__ import annotations
+
+from .cli import main
+
+__all__ = ["main"]

talks_reducer-0.1.0/talks_reducer/__main__.py

@@ -0,0 +1,8 @@
+"""Module executed when running ``python -m talks_reducer``."""
+
+from __future__ import annotations
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

talks_reducer-0.1.0/talks_reducer/audio.py

@@ -0,0 +1,109 @@
+"""Audio processing helpers for the talks reducer pipeline."""
+
+from __future__ import annotations
+
+import math
+import subprocess
+from typing import List, Sequence, Tuple
+
+import numpy as np
+from audiotsm import phasevocoder
+from audiotsm.io.array import ArrayReader, ArrayWriter
+
+
+def get_max_volume(samples: np.ndarray) -> float:
+    """Return the maximum absolute volume in the provided sample array."""
+
+    return float(max(-np.min(samples), np.max(samples)))
+
+
+def is_valid_input_file(filename: str) -> bool:
+    """Check whether ``ffprobe`` recognises the input file and finds an audio stream."""
+
+    command = (
+        'ffprobe -i "{}" -hide_banner -loglevel error -select_streams a'
+        " -show_entries stream=codec_type".format(filename)
+    )
+    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    outs, errs = None, None
+    try:
+        outs, errs = process.communicate(timeout=1)
+    except subprocess.TimeoutExpired:
+        print("Timeout while checking the input file. Aborting. Command:")
+        print(command)
+        process.kill()
+        outs, errs = process.communicate()
+    finally:
+        return len(errs) == 0 and len(outs) > 0
+
+
+def process_audio_chunks(
+    audio_data: np.ndarray,
+    chunks: Sequence[Sequence[int]],
+    samples_per_frame: float,
+    speeds: Sequence[float],
+    audio_fade_envelope_size: int,
+    max_audio_volume: float,
+    *,
+    batch_size: int = 10,
+) -> Tuple[np.ndarray, List[List[int]]]:
+    """Return processed audio and updated chunk timings for the provided chunk list."""
+
+    audio_buffers: List[np.ndarray] = []
+    output_pointer = 0
+    updated_chunks: List[List[int]] = [list(chunk) for chunk in chunks]
+    normaliser = max(max_audio_volume, 1e-9)
+
+    for batch_start in range(0, len(chunks), batch_size):
+        batch_chunks = chunks[batch_start : batch_start + batch_size]
+        batch_audio: List[np.ndarray] = []
+
+        for chunk in batch_chunks:
+            start = int(chunk[0] * samples_per_frame)
+            end = int(chunk[1] * samples_per_frame)
+            audio_chunk = audio_data[start:end]
+
+            if audio_chunk.size == 0:
+                channels = audio_data.shape[1] if audio_data.ndim > 1 else 1
+                batch_audio.append(np.zeros((0, channels)))
+                continue
+
+            reader = ArrayReader(np.transpose(audio_chunk))
+            writer = ArrayWriter(reader.channels)
+            tsm = phasevocoder(reader.channels, speed=speeds[int(chunk[2])])
+            tsm.run(reader, writer)
+            altered_audio_data = np.transpose(writer.data)
+
+            if altered_audio_data.shape[0] < audio_fade_envelope_size:
+                altered_audio_data[:] = 0
+            else:
+                premask = np.arange(audio_fade_envelope_size) / audio_fade_envelope_size
+                mask = np.repeat(
+                    premask[:, np.newaxis], altered_audio_data.shape[1], axis=1
+                )
+                altered_audio_data[:audio_fade_envelope_size] *= mask
+                altered_audio_data[-audio_fade_envelope_size:] *= 1 - mask
+
+            batch_audio.append(altered_audio_data / normaliser)
+
+        for index, chunk in enumerate(batch_chunks):
+            altered_audio_data = batch_audio[index]
+            audio_buffers.append(altered_audio_data)
+
+            end_pointer = output_pointer + altered_audio_data.shape[0]
+            start_output_frame = int(math.ceil(output_pointer / samples_per_frame))
+            end_output_frame = int(math.ceil(end_pointer / samples_per_frame))
+
+            updated_chunks[batch_start + index] = list(chunk[:2]) + [
+                start_output_frame,
+                end_output_frame,
+            ]
+            output_pointer = end_pointer
+
+    if audio_buffers:
+        output_audio_data = np.concatenate(audio_buffers)
+    else:
+        channels = audio_data.shape[1] if audio_data.ndim > 1 else 1
+        output_audio_data = np.zeros((0, channels))
+
+    return output_audio_data, updated_chunks

talks_reducer-0.1.0/talks_reducer/chunks.py

@@ -0,0 +1,92 @@
+"""Chunk creation utilities used by the talks reducer pipeline."""
+
+from __future__ import annotations
+
+from typing import List, Sequence, Tuple
+
+import numpy as np
+
+from .audio import get_max_volume
+
+
+def detect_loud_frames(
+    audio_data: np.ndarray,
+    audio_frame_count: int,
+    samples_per_frame: float,
+    max_audio_volume: float,
+    silent_threshold: float,
+) -> np.ndarray:
+    """Return a boolean array indicating which frames contain loud audio."""
+
+    normaliser = max(max_audio_volume, 1e-9)
+    has_loud_audio = np.zeros(audio_frame_count, dtype=bool)
+
+    for frame_index in range(audio_frame_count):
+        start = int(frame_index * samples_per_frame)
+        end = min(int((frame_index + 1) * samples_per_frame), audio_data.shape[0])
+        audio_chunk = audio_data[start:end]
+        chunk_max_volume = float(get_max_volume(audio_chunk)) / normaliser
+        if chunk_max_volume >= silent_threshold:
+            has_loud_audio[frame_index] = True
+
+    return has_loud_audio
+
+
+def build_chunks(
+    has_loud_audio: np.ndarray, frame_spreadage: int
+) -> Tuple[List[List[int]], np.ndarray]:
+    """Return chunks describing which frame ranges should be retained."""
+
+    audio_frame_count = len(has_loud_audio)
+    chunks: List[List[int]] = [[0, 0, 0]]
+    should_include_frame = np.zeros(audio_frame_count, dtype=bool)
+
+    for frame_index in range(audio_frame_count):
+        start = int(max(0, frame_index - frame_spreadage))
+        end = int(min(audio_frame_count, frame_index + 1 + frame_spreadage))
+        should_include_frame[frame_index] = np.any(has_loud_audio[start:end])
+        if (
+            frame_index >= 1
+            and should_include_frame[frame_index]
+            != should_include_frame[frame_index - 1]
+        ):
+            chunks.append(
+                [chunks[-1][1], frame_index, int(should_include_frame[frame_index - 1])]
+            )
+
+    chunks.append(
+        [
+            chunks[-1][1],
+            audio_frame_count,
+            int(should_include_frame[audio_frame_count - 1]),
+        ]
+    )
+    return chunks[1:], should_include_frame
+
+
+def get_tree_expression(chunks: Sequence[Sequence[int]]) -> str:
+    """Return the FFmpeg expression needed to map chunk timing updates."""
+
+    return "{}/TB/FR".format(_get_tree_expression_rec(chunks))
+
+
+def _get_tree_expression_rec(chunks: Sequence[Sequence[int]]) -> str:
+    if len(chunks) > 1:
+        split_index = int(len(chunks) / 2)
+        center = chunks[split_index]
+        return "if(lt(N,{}),{},{})".format(
+            center[0],
+            _get_tree_expression_rec(chunks[:split_index]),
+            _get_tree_expression_rec(chunks[split_index:]),
+        )
+    chunk = chunks[0]
+    local_speedup = (chunk[3] - chunk[2]) / (chunk[1] - chunk[0])
+    offset = -chunk[0] * local_speedup + chunk[2]
+    return "N*{}{:+}".format(local_speedup, offset)
+
+
+__all__ = [
+    "detect_loud_frames",
+    "build_chunks",
+    "get_tree_expression",
+]

talks_reducer-0.1.0/talks_reducer/cli.py

@@ -0,0 +1,129 @@
+"""Command line interface for the talks reducer package."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import time
+from typing import Dict, List
+
+from . import audio
+from .pipeline import speed_up_video
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    """Create the argument parser used by the command line interface."""
+
+    parser = argparse.ArgumentParser(
+        description="Modifies a video file to play at different speeds when there is sound vs. silence.",
+    )
+    parser.add_argument(
+        "input_file",
+        type=str,
+        nargs="+",
+        help="The video file(s) you want modified. Can be one or more directories and / or single files.",
+    )
+    parser.add_argument(
+        "-o",
+        "--output_file",
+        type=str,
+        dest="output_file",
+        help="The output file. Only usable if a single file is given. If not included, it'll append _ALTERED to the name.",
+    )
+    parser.add_argument(
+        "--temp_folder",
+        type=str,
+        default="TEMP",
+        help="The file path of the temporary working folder.",
+    )
+    parser.add_argument(
+        "-t",
+        "--silent_threshold",
+        type=float,
+        dest="silent_threshold",
+        help="The volume amount that frames' audio needs to surpass to be considered sounded. Defaults to 0.03.",
+    )
+    parser.add_argument(
+        "-S",
+        "--sounded_speed",
+        type=float,
+        dest="sounded_speed",
+        help="The speed that sounded (spoken) frames should be played at. Defaults to 1.",
+    )
+    parser.add_argument(
+        "-s",
+        "--silent_speed",
+        type=float,
+        dest="silent_speed",
+        help="The speed that silent frames should be played at. Defaults to 4.",
+    )
+    parser.add_argument(
+        "-fm",
+        "--frame_margin",
+        type=float,
+        dest="frame_spreadage",
+        help="Some silent frames adjacent to sounded frames are included to provide context. Defaults to 2.",
+    )
+    parser.add_argument(
+        "-sr",
+        "--sample_rate",
+        type=float,
+        dest="sample_rate",
+        help="Sample rate of the input and output videos. Usually extracted automatically by FFmpeg.",
+    )
+    parser.add_argument(
+        "--small",
+        action="store_true",
+        help="Apply small file optimizations: resize video to 720p, audio to 128k bitrate, best compression (uses CUDA if available).",
+    )
+    return parser
+
+
+def _gather_input_files(paths: List[str]) -> List[str]:
+    """Expand provided paths into a flat list of files that contain audio streams."""
+
+    files: List[str] = []
+    for input_path in paths:
+        if os.path.isfile(input_path) and audio.is_valid_input_file(input_path):
+            files.append(os.path.abspath(input_path))
+        elif os.path.isdir(input_path):
+            for file in os.listdir(input_path):
+                candidate = os.path.join(input_path, file)
+                if audio.is_valid_input_file(candidate):
+                    files.append(candidate)
+    return files
+
+
+def main() -> None:
+    """Entry point for the command line interface."""
+
+    parser = _build_parser()
+    parsed_args = parser.parse_args()
+    start_time = time.time()
+
+    files = _gather_input_files(parsed_args.input_file)
+
+    args: Dict[str, object] = {
+        k: v for k, v in vars(parsed_args).items() if v is not None
+    }
+    del args["input_file"]
+
+    if len(files) > 1 and "output_file" in args:
+        del args["output_file"]
+
+    for index, file in enumerate(files):
+        print(f"Processing file {index + 1}/{len(files)} '{os.path.basename(file)}'")
+        local_options = dict(args)
+        local_options["input_file"] = file
+        local_options["small"] = bool(local_options.get("small", False))
+        speed_up_video(**local_options)
+
+    end_time = time.time()
+    total_time = end_time - start_time
+    hours, remainder = divmod(total_time, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    print(f"\nTime: {int(hours)}h {int(minutes)}m {seconds:.2f}s")
+
+
+if __name__ == "__main__":
+    main()

talks_reducer-0.1.0/talks_reducer/ffmpeg.py

@@ -0,0 +1,269 @@
+"""Utilities for discovering and invoking FFmpeg commands."""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+import sys
+from functools import partial
+from typing import List, Optional, Tuple
+
+from tqdm import tqdm as std_tqdm
+
+
+def find_ffmpeg() -> Optional[str]:
+    """Locate the FFmpeg executable in common installation locations."""
+
+    env_override = os.environ.get("TALKS_REDUCER_FFMPEG") or os.environ.get(
+        "FFMPEG_PATH"
+    )
+    if env_override and (os.path.isfile(env_override) or shutil_which(env_override)):
+        return (
+            os.path.abspath(env_override)
+            if os.path.isfile(env_override)
+            else env_override
+        )
+
+    common_paths = [
+        "C:\\ProgramData\\chocolatey\\bin\\ffmpeg.exe",
+        "C:\\Program Files\\ffmpeg\\bin\\ffmpeg.exe",
+        "C:\\ffmpeg\\bin\\ffmpeg.exe",
+        "ffmpeg",
+    ]
+
+    for path in common_paths:
+        if os.path.isfile(path) or shutil_which(path):
+            return os.path.abspath(path) if os.path.isfile(path) else path
+
+    return None
+
+
+def _resolve_ffmpeg_path() -> str:
+    """Resolve the FFmpeg executable path or exit with a helpful message."""
+
+    ffmpeg_path = find_ffmpeg()
+    if not ffmpeg_path:
+        print(
+            "Error: FFmpeg not found. Please install FFmpeg and add it to your PATH or specify the full path.",
+            file=sys.stderr,
+        )
+        raise SystemExit(1)
+
+    print(f"Using FFmpeg at: {ffmpeg_path}")
+    return ffmpeg_path
+
+
+FFMPEG_PATH = _resolve_ffmpeg_path()
+
+tqdm = partial(
+    std_tqdm,
+    bar_format=(
+        "{desc:<20} {percentage:3.0f}%"
+        "|{bar:10}|"
+        " {n_fmt:>6}/{total_fmt:>6} [{elapsed:^5}<{remaining:^5}, {rate_fmt}{postfix}]"
+    ),
+)
+
+
+def check_cuda_available(ffmpeg_path: str = FFMPEG_PATH) -> bool:
+    """Return whether CUDA hardware encoders are available in the FFmpeg build."""
+
+    try:
+        result = subprocess.run(
+            [ffmpeg_path, "-encoders"], capture_output=True, text=True, timeout=5
+        )
+    except (
+        subprocess.TimeoutExpired,
+        subprocess.CalledProcessError,
+        FileNotFoundError,
+    ):
+        return False
+
+    if result.returncode != 0:
+        return False
+
+    encoder_list = result.stdout.lower()
+    return any(
+        encoder in encoder_list for encoder in ["h264_nvenc", "hevc_nvenc", "nvenc"]
+    )
+
+
+def run_timed_ffmpeg_command(command: str, **kwargs) -> None:
+    """Execute an FFmpeg command while streaming progress information to ``tqdm``."""
+
+    import shlex
+
+    try:
+        args = shlex.split(command)
+    except Exception as exc:  # pragma: no cover - defensive logging
+        print(f"Error parsing command: {exc}", file=sys.stderr)
+        raise
+
+    try:
+        process = subprocess.Popen(
+            args,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
+            bufsize=1,
+            errors="replace",
+        )
+    except Exception as exc:  # pragma: no cover - defensive logging
+        print(f"Error starting FFmpeg: {exc}", file=sys.stderr)
+        raise
+
+    with tqdm(**kwargs) as progress:
+        while True:
+            line = process.stderr.readline()
+            if not line and process.poll() is not None:
+                break
+
+            if not line:
+                continue
+
+            sys.stderr.write(line)
+            sys.stderr.flush()
+
+            match = re.search(r"frame=\s*(\d+)", line)
+            if match:
+                try:
+                    new_frame = int(match.group(1))
+                    if progress.total < new_frame:
+                        progress.total = new_frame
+                    progress.update(new_frame - progress.n)
+                except (ValueError, IndexError):
+                    pass
+
+        process.wait()
+
+        if process.returncode != 0:
+            error_output = process.stderr.read()
+            print(
+                f"\nFFmpeg error (return code {process.returncode}):", file=sys.stderr
+            )
+            print(error_output, file=sys.stderr)
+            raise subprocess.CalledProcessError(process.returncode, args)
+
+        if progress.n < progress.total:
+            progress.update(progress.total - progress.n)
+
+
+def build_extract_audio_command(
+    input_file: str,
+    output_wav: str,
+    sample_rate: int,
+    audio_bitrate: str,
+    hwaccel: Optional[List[str]] = None,
+    ffmpeg_path: str = FFMPEG_PATH,
+) -> str:
+    """Build the FFmpeg command used to extract audio into a temporary WAV file."""
+
+    hwaccel = hwaccel or []
+    command_parts: List[str] = [f'"{ffmpeg_path}"']
+    command_parts.extend(hwaccel)
+    command_parts.extend(
+        [
+            f'-i "{input_file}"',
+            f"-ab {audio_bitrate} -ac 2",
+            f"-ar {sample_rate}",
+            "-vn",
+            f'"{output_wav}"',
+            "-hide_banner -loglevel warning -stats",
+        ]
+    )
+    return " ".join(command_parts)
+
+
+def build_video_commands(
+    input_file: str,
+    audio_file: str,
+    filter_script: str,
+    output_file: str,
+    *,
+    ffmpeg_path: str = FFMPEG_PATH,
+    cuda_available: bool,
+    small: bool,
+) -> Tuple[str, Optional[str], bool]:
+    """Create the FFmpeg command strings used to render the final video output."""
+
+    global_parts: List[str] = [f'"{ffmpeg_path}"', "-y"]
+    hwaccel_args: List[str] = []
+
+    if cuda_available and not small:
+        hwaccel_args = ["-hwaccel", "cuda", "-hwaccel_output_format", "cuda"]
+        global_parts.extend(hwaccel_args)
+    elif small and cuda_available:
+        pass
+
+    input_parts = [f'-i "{input_file}"', f'-i "{audio_file}"']
+
+    output_parts = [
+        "-map 0 -map -0:a -map 1:a",
+        f'-filter_script:v "{filter_script}"',
+    ]
+
+    video_encoder_args: List[str]
+    fallback_encoder_args: List[str] = []
+    use_cuda_encoder = False
+
+    if small:
+        if cuda_available:
+            use_cuda_encoder = True
+            video_encoder_args = [
+                "-c:v h264_nvenc",
+                "-preset p1",
+                "-cq 28",
+                "-tune",
+                "ll",
+            ]
+            fallback_encoder_args = [
+                "-c:v libx264",
+                "-preset veryfast",
+                "-crf 24",
+                "-tune",
+                "zerolatency",
+            ]
+        else:
+            video_encoder_args = [
+                "-c:v libx264",
+                "-preset veryfast",
+                "-crf 24",
+                "-tune",
+                "zerolatency",
+            ]
+    else:
+        global_parts.append("-filter_complex_threads 1")
+        if cuda_available:
+            video_encoder_args = ["-c:v h264_nvenc"]
+            use_cuda_encoder = True
+        else:
+            video_encoder_args = ["-c:v copy"]
+
+    audio_parts = ["-c:a aac", f'"{output_file}"', "-loglevel info -stats -hide_banner"]
+
+    full_command_parts = (
+        global_parts + input_parts + output_parts + video_encoder_args + audio_parts
+    )
+    command_str = " ".join(full_command_parts)
+
+    fallback_command_str: Optional[str] = None
+    if fallback_encoder_args:
+        fallback_parts = (
+            global_parts
+            + input_parts
+            + output_parts
+            + fallback_encoder_args
+            + audio_parts
+        )
+        fallback_command_str = " ".join(fallback_parts)
+
+    return command_str, fallback_command_str, use_cuda_encoder
+
+
+def shutil_which(cmd: str) -> Optional[str]:
+    """Wrapper around :func:`shutil.which` for easier testing."""
+
+    from shutil import which as _which
+
+    return _which(cmd)

talks_reducer-0.1.0/talks_reducer/pipeline.py

@@ -0,0 +1,244 @@
+"""High-level pipeline orchestration for Talks Reducer."""
+
+from __future__ import annotations
+
+import math
+import os
+import re
+import subprocess
+from typing import Dict, Optional
+
+import numpy as np
+from scipy.io import wavfile
+
+from . import audio as audio_utils
+from . import chunks as chunk_utils
+from .ffmpeg import (
+    FFMPEG_PATH,
+    build_extract_audio_command,
+    build_video_commands,
+    check_cuda_available,
+    run_timed_ffmpeg_command,
+)
+
+
+def _input_to_output_filename(filename: str, small: bool = False) -> str:
+    dot_index = filename.rfind(".")
+    suffix = "_speedup_small" if small else "_speedup"
+    return filename[:dot_index] + suffix + filename[dot_index:]
+
+
+def _create_path(path: str) -> None:
+    try:
+        os.mkdir(path)
+    except OSError as exc:  # pragma: no cover - defensive logging
+        raise AssertionError(
+            "Creation of the directory failed. (The TEMP folder may already exist. Delete or rename it, and try again.)"
+        ) from exc
+
+
+def _delete_path(path: str) -> None:
+    import time
+    from shutil import rmtree
+
+    try:
+        rmtree(path, ignore_errors=False)
+        for i in range(5):
+            if not os.path.exists(path):
+                return
+            time.sleep(0.01 * i)
+    except OSError as exc:  # pragma: no cover - defensive logging
+        print(f"Deletion of the directory {path} failed")
+        print(exc)
+
+
+def _extract_video_metadata(input_file: str, frame_rate: float) -> Dict[str, float]:
+    command = (
+        'ffprobe -i "{}" -hide_banner -loglevel error -select_streams v'
+        " -show_entries format=duration:stream=avg_frame_rate".format(input_file)
+    )
+    process = subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        bufsize=1,
+        universal_newlines=True,
+    )
+    stdout, _ = process.communicate()
+
+    match_frame_rate = re.search(r"frame_rate=(\d*)/(\d*)", str(stdout))
+    if match_frame_rate is not None:
+        frame_rate = float(match_frame_rate.group(1)) / float(match_frame_rate.group(2))
+
+    match_duration = re.search(r"duration=([\d.]*)", str(stdout))
+    original_duration = float(match_duration.group(1)) if match_duration else 0.0
+
+    return {"frame_rate": frame_rate, "duration": original_duration}
+
+
+def _ensure_two_dimensional(audio_data: np.ndarray) -> np.ndarray:
+    if audio_data.ndim == 1:
+        return audio_data[:, np.newaxis]
+    return audio_data
+
+
+def _prepare_output_audio(output_audio_data: np.ndarray) -> np.ndarray:
+    if output_audio_data.ndim == 2 and output_audio_data.shape[1] == 1:
+        return output_audio_data[:, 0]
+    return output_audio_data
+
+
+def speed_up_video(
+    input_file: str,
+    output_file: Optional[str] = None,
+    frame_rate: float = 30,
+    sample_rate: int = 44100,
+    silent_threshold: float = 0.03,
+    silent_speed: float = 4.0,
+    sounded_speed: float = 1.0,
+    frame_spreadage: int = 2,
+    audio_fade_envelope_size: int = 400,
+    temp_folder: str = "TEMP",
+    small: bool = False,
+) -> None:
+    """Speed up a video by shortening silent sections while keeping sounded sections intact."""
+
+    if output_file is None:
+        output_file = _input_to_output_filename(input_file, small)
+
+    cuda_available = check_cuda_available()
+
+    if os.path.exists(temp_folder):
+        _delete_path(temp_folder)
+    _create_path(temp_folder)
+
+    metadata = _extract_video_metadata(input_file, frame_rate)
+    frame_rate = metadata["frame_rate"]
+    original_duration = metadata["duration"]
+
+    hwaccel = (
+        ["-hwaccel", "cuda", "-hwaccel_output_format", "cuda"] if cuda_available else []
+    )
+    audio_bitrate = "128k" if small else "160k"
+    audio_wav = os.path.join(temp_folder, "audio.wav")
+
+    extract_command = build_extract_audio_command(
+        input_file,
+        audio_wav,
+        sample_rate,
+        audio_bitrate,
+        hwaccel,
+    )
+
+    run_timed_ffmpeg_command(
+        extract_command,
+        total=int(original_duration * frame_rate),
+        unit="frames",
+        desc="Extracting audio:",
+    )
+
+    wav_sample_rate, audio_data = wavfile.read(audio_wav)
+    audio_data = _ensure_two_dimensional(audio_data)
+    audio_sample_count = audio_data.shape[0]
+    max_audio_volume = audio_utils.get_max_volume(audio_data)
+
+    print("\nProcessing Information:")
+    print(f"- Max Audio Volume: {max_audio_volume}")
+    print(f"- Processing on: {'GPU (CUDA)' if cuda_available else 'CPU'}")
+    if small:
+        print("- Small mode: 720p video, 128k audio, optimized compression")
+
+    samples_per_frame = wav_sample_rate / frame_rate
+    audio_frame_count = int(math.ceil(audio_sample_count / samples_per_frame))
+
+    has_loud_audio = chunk_utils.detect_loud_frames(
+        audio_data,
+        audio_frame_count,
+        samples_per_frame,
+        max_audio_volume,
+        silent_threshold,
+    )
+
+    chunks, _ = chunk_utils.build_chunks(has_loud_audio, frame_spreadage)
+
+    print(f"Generated {len(chunks)} chunks:")
+    for index, chunk in enumerate(chunks[:5]):
+        print(f"  Chunk {index}: {chunk}")
+    if len(chunks) > 5:
+        print(f"  ... and {len(chunks) - 5} more chunks")
+
+    new_speeds = [silent_speed, sounded_speed]
+    output_audio_data, updated_chunks = audio_utils.process_audio_chunks(
+        audio_data,
+        chunks,
+        samples_per_frame,
+        new_speeds,
+        audio_fade_envelope_size,
+        max_audio_volume,
+    )
+
+    audio_new_path = os.path.join(temp_folder, "audioNew.wav")
+    wavfile.write(audio_new_path, sample_rate, _prepare_output_audio(output_audio_data))
+
+    expression = chunk_utils.get_tree_expression(updated_chunks)
+    filter_graph_path = os.path.join(temp_folder, "filterGraph.txt")
+    with open(filter_graph_path, "w", encoding="utf-8") as filter_graph_file:
+        filter_parts = []
+        if small:
+            filter_parts.append("scale=-2:720")
+        filter_parts.append(f"fps=fps={frame_rate}")
+        filter_parts.append(f'setpts={expression.replace(",", "\\,")}')
+        filter_graph_file.write(",".join(filter_parts))
+
+    command_str, fallback_command_str, use_cuda_encoder = build_video_commands(
+        input_file,
+        audio_new_path,
+        filter_graph_path,
+        output_file,
+        ffmpeg_path=FFMPEG_PATH,
+        cuda_available=cuda_available,
+        small=small,
+    )
+
+    output_dir = os.path.dirname(os.path.abspath(output_file))
+    if output_dir and not os.path.exists(output_dir):
+        print(f"Creating output directory: {output_dir}")
+        os.makedirs(output_dir, exist_ok=True)
+
+    print("\nExecuting FFmpeg command:")
+    print(command_str)
+
+    if not os.path.exists(audio_new_path):
+        print("ERROR: Audio file not found!")
+        _delete_path(temp_folder)
+        return
+
+    if not os.path.exists(filter_graph_path):
+        print("ERROR: Filter file not found!")
+        _delete_path(temp_folder)
+        return
+
+    try:
+        run_timed_ffmpeg_command(
+            command_str,
+            total=updated_chunks[-1][3],
+            unit="frames",
+            desc="Generating final:",
+        )
+    except subprocess.CalledProcessError as exc:
+        if fallback_command_str and use_cuda_encoder:
+            print("CUDA encoding failed, retrying with CPU encoder...")
+            run_timed_ffmpeg_command(
+                fallback_command_str,
+                total=updated_chunks[-1][3],
+                unit="frames",
+                desc="Generating final (fallback):",
+            )
+        else:
+            print(f"\nError running FFmpeg command: {exc}")
+            print(
+                "Please check if all input files exist and FFmpeg has proper permissions."
+            )
+            raise
+    finally:
+        _delete_path(temp_folder)

talks_reducer-0.1.0/talks_reducer.egg-info/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: talks-reducer
+Version: 0.1.0
+Summary: CLI for speeding up long-form talks by removing silence
+Author: Talks Reducer Maintainers
+License: MIT License
+        
+        Copyright (c) 2019 carykh
+        Copyright (c) 2020 gegell
+        Copyright (c) 2025 Stanislav Popov
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: audiotsm>=0.1.2
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: numpy<2.0.0,>=1.22.0
+Requires-Dist: tqdm>=4.65.0
+Dynamic: license-file
+
+# Talks Reducer
+Talks Reducer shortens long-form presentations by removing silent gaps and optionally re-encoding them to smaller files. The
+project was renamed from **jumpcutter** to emphasize its focus on conference talks and lectures.
+
+When CUDA-capable hardware is available the pipeline leans on GPU encoders to keep export times low, but it still runs great on
+CPUs.
+
+## Repository Structure
+- `talks_reducer/` — Python package that exposes the CLI and reusable pipeline:
+  - `cli.py` parses arguments and dispatches to the pipeline.
+  - `pipeline.py` orchestrates FFmpeg, audio processing, and temporary assets.
+  - `audio.py` handles audio validation, volume analysis, and phase vocoder processing.
+  - `chunks.py` builds timing metadata and FFmpeg expressions for frame selection.
+  - `ffmpeg.py` discovers the FFmpeg binary, checks CUDA availability, and assembles command strings.
+- `requirements.txt` — Python dependencies for local development.
+- `default.nix` — reproducible environment definition for Nix users.
+- `CONTRIBUTION.md` — development workflow, formatting expectations, and release checklist.
+- `AGENTS.md` — maintainer tips and coding conventions for this repository.
+
+## Example
+- 1h 37m, 571 MB — Original OBS video
+- 1h 19m, 751 MB — Talks Reducer
+- 1h 19m, 171 MB — Talks Reducer `--small`
+
+The `--small` preset applies a 720p video scale and 128 kbps audio bitrate, making it useful for sharing talks over constrained
+connections. Without `--small`, the script aims to preserve original quality while removing silence.
+
+## Highlights
+- Builds on gegell's classic jumpcutter workflow with more efficient frame and audio processing
+- Generates FFmpeg filter graphs instead of writing temporary frames to disk
+- Streams audio transformations in memory to avoid slow intermediate files
+- Accepts multiple inputs or directories of recordings in a single run
+- Provides progress feedback via `tqdm`
+- Automatically detects NVENC availability, so you no longer need to pass `--cuda`
+
+## Processing Pipeline
+1. Validate that each input file contains an audio stream using `ffprobe`.
+2. Extract audio and calculate loudness to identify silent regions.
+3. Stretch the non-silent segments with `audiotsm` to maintain speech clarity.
+4. Stitch the processed audio and video together with FFmpeg, using NVENC if the GPU encoders are detected.
+
+## Recent Updates
+- **October 2025** — Project renamed to *Talks Reducer* across documentation and scripts.
+- **October 2025** — Added `--small` preset with 720p/128 kbps defaults for bandwidth-friendly exports.
+- **October 2025** — Removed the `--cuda` flag; CUDA/NVENC support is now auto-detected.
+- **October 2025** — Improved `--small` encoder arguments to balance size and clarity.
+- **October 2025** — CLI argument parsing fixes to prevent crashes on invalid combinations.
+- **October 2025** — Added example output comparison to the README.
+
+## Quick Start
+1. Install FFmpeg and ensure it is on your `PATH`
+2. Install Talks Reducer with `pip install talks-reducer` (this exposes the `talks-reducer` command)
+3. Inspect available options with `talks-reducer --help`
+4. Process a recording using `talks-reducer /path/to/video`
+
+## Requirements
+- Python 3 with `numpy`, `scipy`, `audiotsm`, and `tqdm`
+- FFmpeg with optional NVIDIA NVENC support for CUDA acceleration
+
+## Contributing
+See `CONTRIBUTION.md` for development setup details and guidance on sharing improvements.
+
+## License
+Talks Reducer is released under the MIT License. See `LICENSE` for the full text.

talks_reducer-0.1.0/talks_reducer.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+talks_reducer/__init__.py
+talks_reducer/__main__.py
+talks_reducer/audio.py
+talks_reducer/chunks.py
+talks_reducer/cli.py
+talks_reducer/ffmpeg.py
+talks_reducer/pipeline.py
+talks_reducer.egg-info/PKG-INFO
+talks_reducer.egg-info/SOURCES.txt
+talks_reducer.egg-info/dependency_links.txt
+talks_reducer.egg-info/entry_points.txt
+talks_reducer.egg-info/requires.txt
+talks_reducer.egg-info/top_level.txt

talks_reducer-0.1.0/talks_reducer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

talks_reducer-0.1.0/talks_reducer.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+talks-reducer = talks_reducer.cli:main

talks_reducer-0.1.0/talks_reducer.egg-info/requires.txt

@@ -0,0 +1,4 @@
+audiotsm>=0.1.2
+scipy>=1.10.0
+numpy<2.0.0,>=1.22.0
+tqdm>=4.65.0

talks_reducer-0.1.0/talks_reducer.egg-info/top_level.txt

@@ -0,0 +1 @@
+talks_reducer