ffmpeg4discord 0.1.0__tar.gz

ffmpeg4discord-0.1.0/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.1
+Name: ffmpeg4discord
+Version: 0.1.0
+Summary: A tool to help convert a video file to a target file size.
+Author-email: Zach Fleeman <zfleeman@gmail.com>
+Project-URL: Homepage, https://github.com/zfleeman/ffmpeg4discord
+Project-URL: Issues, https://github.com/zfleeman/ffmpeg4discord/issues
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: Flask==3.0.1
+Requires-Dist: ffmpeg-python==0.2.0
+
+# `ff4d` -- Target File Size Video Compression for Discord with FFmpeg
+This repository houses scripts and applications to assist with compressing a video file to a desired size. 
+
+`ff4d` takes a video file as its input and encodes it to be less than 25MB unless specified otherwise. Discord's free-tier file size sharing limit is 25MB. You can change the file's name in a way that trims the file to a timestamped section. I created this package to share large NVIDIA ShadowPlay clips on Discord quickly, without the need for a visual editor. 
+
+The `TwoPass()` Class showcases a 2-pass encoding methodology for the `ffmpeg-python` library, which is not well-documented on the web. The Class also supports a few FFmpeg video filters, like cropping and resolution scaling. It can be used in a variety of different audio/video workflows.
+
+## Installation and Usage
+
+This package works with Python >= 3.8. For Windows users, ensure that Python is added to your system's PATH.
+
+Install this package with the following command.
+
+```
+pip install ffmpeg4discord
+```
+
+You must first have FFmpeg installed on your system. `ffmpeg` needs to be registered in your PATH. macOS or Linux users can use their favorite package manager to do this, but this process is a little more tricky for Windows users.
+
+### Help for Windows users
+
+After installing this package, Windows users can run this command in a terminal to download the necessary `ffmpeg` binaries:
+
+```
+install-ffmpeg-windows
+```
+
+This will place `ffmpeg.exe`, `ffprobe.exe`, and `ffplay.exe` into the same location as your Python executable.
+
+## Usage
+
+Run the program with:
+
+```
+ff4d cool_clip.mp4
+```
+
+I've had a good time using this command with a Batch file on Windows. Refer to the [Sample Batch File](https://github.com/zfleeman/ffmpeg4discord#sample-batch-file) section for more information.
+
+### File name formatting
+1) `000020.mp4`
+    - This clips and compresses the video from 00:00:20 to the end of the clip.
+2) `000020-000145.mp4`
+    - This clips and compresses the video from 00:00:20 to 00:01:45.
+3) `SomethingElse.mp4`
+    - Compresses the entire video if the first six characters of the file's name aren't numeric.
+
+### Optional Arguments
+- `-o`, `--output`
+  - default: the current working directory
+  - If there is a folder that you want all of your smaller clips to land in, specify it with this argument.
+- `-s`, `--filesize`
+  - default: `25.0`
+  - Increase or decrease this value if you want to compress your video to something other than the 8MB Discord limit.
+- `-a`, `--audio-br`
+  - You can change this value if you want to increase or decrease your audio bitrate. Lowering it will allow for a slight increase in the compressed file's video bitrate.
+- `-r`, `--resolution`
+  - Example: `1280x720`
+  - Modify this value to change the output resolution of your video file. I'd recommend lowering your output resolution by 1.5x or 2x. Example: `1920x1080` video should get an output resolution of `1280x720`
+- `-x`, `--crop`
+  - Example: `255x0x1410x1080`
+  - From the top-left of your video, this example goes 255 pixels to the right, 0 pixels down, and it carves out a 1410x1080 section of the video.
+  - [FFmpeg crop documentation](https://ffmpeg.org/ffmpeg-filters.html#Examples-61)
+- `--web`
+  - A Boolean flag. No value is needed after the flag. See [Web UI](#web-ui) for more information on the Web UI.
+- `--config`
+  - Example: `custom_run_config.json`
+  - Path to a json file containing the configuration for the above parameters. This config file takes precedence over all of the other flags.
+
+### JSON Configuration
+If your encoding job will always be the same, you can reference a JSON configuration file instead of passing a long list of arguments to the command line.
+
+```
+{
+    "target_filesize": 8.0,
+    "audio_br": 96,
+    "crop": "",
+    "resolution": "",
+    "codec": "libx264",
+    "times": {
+        "from": "00:00:00",
+        "to": "00:00:40"
+    }
+}
+```
+
+Notes:
+- All of the keys except for `"from"` and `"to"` must always be present. Those entries can be deleted if you do not have a timestamp entry for the given field. Examples: 
+  - `"times": {}` -> if you do not wish to trim the start and stop time of the file. This falls back to the [file name formatting](https://github.com/zfleeman/ffmpeg4discord#file-name-formatting).
+  - `"times": {"from": "00:00:10"}` -> trim the clip from `00:00:10` to the end of the file
+  - `"times": {"to": "00:00:20"}` -> trim the clip from the beginning of the file up to `00:00:20`
+- You can set `audio_br` to `null` if you want to maintain the clip's audio bitrate.
+
+## Detailed Example
+
+```
+ff4d 000050-000145.mp4 \
+    -c 1280x0x2560x1440 \
+    -r 1920x1080 \
+    -s 50 \
+    -a 48 \
+    -o D:/shadowplay/
+```
+
+The example above takes a 5120x1440 resolution video as its input. The script trims the video from 00:00:50 to 00:01:45 (specified in the [file name](https://github.com/zfleeman/ffmpeg4discord#file-name-formatting)). It crops a 2560x1440 section starting at 1280 pixels from the top-left and 0 pixels down (`-c`). The output file will be located in `D:/shadowplay/` (`-o`) with a new resolution of 1920x1080 (`-r`), and it will be 50MB (`-s`). The audio bitrate will be reduced to 48k (`-a`) as well, but that's probably going to sound terrible.
+
+![](https://i.imgur.com/WJXA723.png)
+
+## Web UI
+
+The web UI can be activated by adding `--web` to your `ff4d` call.
+
+```
+ff4d cool_clip.mp4 -r 1280x720 -s 20 --web
+```
+
+That command will spin up a Flask server on your local machine and launch a rendered webpage with the video as the centerpiece. The flags you provide to `ff4d` will fill in the defaults for the form. You can override/replace the values.
+
+You can drag the video playhead to different portions of the video and click the "Set Start/End Time" buttons to specify the section of the video you want to be clipped out. You can also use the range sliders underneath the buttons if you prefer. A "Preview Selection" button is provided for your convenience, and it does what it sounds like.
+
+https://github.com/zfleeman/ffmpeg4discord/assets/1808564/ff323bcb-4747-437b-808f-ce48b8c269ce
+
+The Flask server doesn't automatically stop itself, so you'll have to terminate it manually by closing the terminal it leaves hanging.
+
+## Sample Batch File
+
+To enable "drag and drop" functionality for this package, Windows users can create a `.bat` file with the following code snippet. Once the file is created, you can drag and drop any `.mp4` file on top of it, and it will run with the flags specified in the "[Optional Arguments](https://github.com/zfleeman/ffmpeg4discord#file-name-formatting)" section. This example is a Batch file that will launch the web UI.
+
+```batch
+@echo off
+Set filename=%1
+ff4d %filename% -o "C:/output/folder/" --web
+DEL "ffmpeg2*"
+PAUSE
+```
+
+## Thanks!
+
+Yes, this is a simple collection of Python files using FFmpeg tricks that is masquerading as a robust Audio/Video tool. But! I use this nearly every day to quickly share videos with people on various messaging apps that have built-in video players. I don't have to share a link that embeds a video player this way, and I guess that's important to me?
+
+I like working on this! Enjoy!

ffmpeg4discord-0.1.0/README.md

@@ -0,0 +1,141 @@
+# `ff4d` -- Target File Size Video Compression for Discord with FFmpeg
+This repository houses scripts and applications to assist with compressing a video file to a desired size. 
+
+`ff4d` takes a video file as its input and encodes it to be less than 25MB unless specified otherwise. Discord's free-tier file size sharing limit is 25MB. You can change the file's name in a way that trims the file to a timestamped section. I created this package to share large NVIDIA ShadowPlay clips on Discord quickly, without the need for a visual editor. 
+
+The `TwoPass()` Class showcases a 2-pass encoding methodology for the `ffmpeg-python` library, which is not well-documented on the web. The Class also supports a few FFmpeg video filters, like cropping and resolution scaling. It can be used in a variety of different audio/video workflows.
+
+## Installation and Usage
+
+This package works with Python >= 3.8. For Windows users, ensure that Python is added to your system's PATH.
+
+Install this package with the following command.
+
+```
+pip install ffmpeg4discord
+```
+
+You must first have FFmpeg installed on your system. `ffmpeg` needs to be registered in your PATH. macOS or Linux users can use their favorite package manager to do this, but this process is a little more tricky for Windows users.
+
+### Help for Windows users
+
+After installing this package, Windows users can run this command in a terminal to download the necessary `ffmpeg` binaries:
+
+```
+install-ffmpeg-windows
+```
+
+This will place `ffmpeg.exe`, `ffprobe.exe`, and `ffplay.exe` into the same location as your Python executable.
+
+## Usage
+
+Run the program with:
+
+```
+ff4d cool_clip.mp4
+```
+
+I've had a good time using this command with a Batch file on Windows. Refer to the [Sample Batch File](https://github.com/zfleeman/ffmpeg4discord#sample-batch-file) section for more information.
+
+### File name formatting
+1) `000020.mp4`
+    - This clips and compresses the video from 00:00:20 to the end of the clip.
+2) `000020-000145.mp4`
+    - This clips and compresses the video from 00:00:20 to 00:01:45.
+3) `SomethingElse.mp4`
+    - Compresses the entire video if the first six characters of the file's name aren't numeric.
+
+### Optional Arguments
+- `-o`, `--output`
+  - default: the current working directory
+  - If there is a folder that you want all of your smaller clips to land in, specify it with this argument.
+- `-s`, `--filesize`
+  - default: `25.0`
+  - Increase or decrease this value if you want to compress your video to something other than the 8MB Discord limit.
+- `-a`, `--audio-br`
+  - You can change this value if you want to increase or decrease your audio bitrate. Lowering it will allow for a slight increase in the compressed file's video bitrate.
+- `-r`, `--resolution`
+  - Example: `1280x720`
+  - Modify this value to change the output resolution of your video file. I'd recommend lowering your output resolution by 1.5x or 2x. Example: `1920x1080` video should get an output resolution of `1280x720`
+- `-x`, `--crop`
+  - Example: `255x0x1410x1080`
+  - From the top-left of your video, this example goes 255 pixels to the right, 0 pixels down, and it carves out a 1410x1080 section of the video.
+  - [FFmpeg crop documentation](https://ffmpeg.org/ffmpeg-filters.html#Examples-61)
+- `--web`
+  - A Boolean flag. No value is needed after the flag. See [Web UI](#web-ui) for more information on the Web UI.
+- `--config`
+  - Example: `custom_run_config.json`
+  - Path to a json file containing the configuration for the above parameters. This config file takes precedence over all of the other flags.
+
+### JSON Configuration
+If your encoding job will always be the same, you can reference a JSON configuration file instead of passing a long list of arguments to the command line.
+
+```
+{
+    "target_filesize": 8.0,
+    "audio_br": 96,
+    "crop": "",
+    "resolution": "",
+    "codec": "libx264",
+    "times": {
+        "from": "00:00:00",
+        "to": "00:00:40"
+    }
+}
+```
+
+Notes:
+- All of the keys except for `"from"` and `"to"` must always be present. Those entries can be deleted if you do not have a timestamp entry for the given field. Examples: 
+  - `"times": {}` -> if you do not wish to trim the start and stop time of the file. This falls back to the [file name formatting](https://github.com/zfleeman/ffmpeg4discord#file-name-formatting).
+  - `"times": {"from": "00:00:10"}` -> trim the clip from `00:00:10` to the end of the file
+  - `"times": {"to": "00:00:20"}` -> trim the clip from the beginning of the file up to `00:00:20`
+- You can set `audio_br` to `null` if you want to maintain the clip's audio bitrate.
+
+## Detailed Example
+
+```
+ff4d 000050-000145.mp4 \
+    -c 1280x0x2560x1440 \
+    -r 1920x1080 \
+    -s 50 \
+    -a 48 \
+    -o D:/shadowplay/
+```
+
+The example above takes a 5120x1440 resolution video as its input. The script trims the video from 00:00:50 to 00:01:45 (specified in the [file name](https://github.com/zfleeman/ffmpeg4discord#file-name-formatting)). It crops a 2560x1440 section starting at 1280 pixels from the top-left and 0 pixels down (`-c`). The output file will be located in `D:/shadowplay/` (`-o`) with a new resolution of 1920x1080 (`-r`), and it will be 50MB (`-s`). The audio bitrate will be reduced to 48k (`-a`) as well, but that's probably going to sound terrible.
+
+![](https://i.imgur.com/WJXA723.png)
+
+## Web UI
+
+The web UI can be activated by adding `--web` to your `ff4d` call.
+
+```
+ff4d cool_clip.mp4 -r 1280x720 -s 20 --web
+```
+
+That command will spin up a Flask server on your local machine and launch a rendered webpage with the video as the centerpiece. The flags you provide to `ff4d` will fill in the defaults for the form. You can override/replace the values.
+
+You can drag the video playhead to different portions of the video and click the "Set Start/End Time" buttons to specify the section of the video you want to be clipped out. You can also use the range sliders underneath the buttons if you prefer. A "Preview Selection" button is provided for your convenience, and it does what it sounds like.
+
+https://github.com/zfleeman/ffmpeg4discord/assets/1808564/ff323bcb-4747-437b-808f-ce48b8c269ce
+
+The Flask server doesn't automatically stop itself, so you'll have to terminate it manually by closing the terminal it leaves hanging.
+
+## Sample Batch File
+
+To enable "drag and drop" functionality for this package, Windows users can create a `.bat` file with the following code snippet. Once the file is created, you can drag and drop any `.mp4` file on top of it, and it will run with the flags specified in the "[Optional Arguments](https://github.com/zfleeman/ffmpeg4discord#file-name-formatting)" section. This example is a Batch file that will launch the web UI.
+
+```batch
+@echo off
+Set filename=%1
+ff4d %filename% -o "C:/output/folder/" --web
+DEL "ffmpeg2*"
+PAUSE
+```
+
+## Thanks!
+
+Yes, this is a simple collection of Python files using FFmpeg tricks that is masquerading as a robust Audio/Video tool. But! I use this nearly every day to quickly share videos with people on various messaging apps that have built-in video players. I don't have to share a link that embeds a video player this way, and I guess that's important to me?
+
+I like working on this! Enjoy!

ffmpeg4discord-0.1.0/ffmpeg4discord/app.py

@@ -0,0 +1,101 @@
+import sys
+import os
+from glob import glob
+import webbrowser
+from flask import Flask, render_template, url_for, request
+import time
+import threading
+from pathlib import Path
+
+sys.dont_write_bytecode = True
+from ffmpeg4discord import arguments
+from ffmpeg4discord.twopass import TwoPass
+
+# get args from the command line
+args = arguments.get_args()
+web = args.pop("web")
+port = args.pop("port")
+path = Path(args["filename"]).resolve()
+args["filename"] = path
+
+# instantiate the TwoPass class
+twopass = TwoPass(**args)
+
+
+def twopass_loop(target_filesize: float) -> str:
+    while twopass.run() >= target_filesize:
+        print(
+            f"\nThe output file size ({round(twopass.output_filesize, 2)}MB) is still above the target of {target_filesize}MB.\nRestarting...\n"
+        )
+        os.remove(twopass.output_filename)
+
+        # adjust the class's target file size to set a lower bitrate for the next run
+        twopass.target_filesize -= 0.2
+
+    success_message = f"Your compressed video file ({round(twopass.output_filesize, 2)}MB) is located at {Path(twopass.output_filename).resolve()}"
+    print(success_message)
+
+    return success_message
+
+
+def seconds_to_timestamp(seconds: int) -> str:
+    hours, remainder = divmod(seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+
+    # Use f-strings to format the timestamp
+    timestamp = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+    return timestamp
+
+
+def open_browser() -> None:
+    time.sleep(0.5)
+    webbrowser.open(f"http://localhost:{port}")
+
+
+def main() -> None:
+    if web:
+        app = Flask(__name__, static_folder=path.parent)
+
+        @app.route("/")
+        def index():
+            return render_template(
+                "web.html", file_url=url_for("static", filename=path.name), twopass=twopass, alert_hidden=True
+            )
+
+        @app.route("/encode", methods=["POST"])
+        def form_twopass():
+            # generate new times from the selection
+            ss = int(request.form.get("startTime"))
+            to = int(request.form.get("endTime"))
+            twopass.length = to - ss
+            twopass.times = {"ss": seconds_to_timestamp(ss), "to": seconds_to_timestamp(to)}
+            target_filesize = float(request.form.get("target_filesize"))
+
+            # update TwoPass from web form
+            twopass.resolution = request.form.get("resolution")
+            twopass.target_filesize = target_filesize
+            twopass.audio_br = float(request.form.get("audio_br")) * 1000
+            twopass.crop = request.form.get("crop")
+            twopass.output_dir = request.form.get("output_dir")
+
+            success_message = twopass_loop(target_filesize)
+
+            for file in glob("ffmpeg2pass*"):
+                os.remove(file)
+
+            return render_template(
+                "web.html",
+                file_url=url_for("static", filename=path.name),
+                twopass=twopass,
+                alert=success_message,
+            )
+
+        threading.Thread(target=open_browser, name="Open Browser").start()
+        app.run("0.0.0.0", port=port)
+    else:
+        twopass_loop(twopass.target_filesize)
+
+
+if __name__ == "__main__":
+    main()

ffmpeg4discord-0.1.0/ffmpeg4discord/arguments.py

@@ -0,0 +1,37 @@
+from argparse import ArgumentParser, Namespace, BooleanOptionalAction
+
+
+def get_args() -> Namespace:
+    parser = ArgumentParser(
+        prog="ffmpeg4discord",
+        description="This script takes a video file and compresses it to a target file size.",
+        epilog="For more help: https://github.com/zfleeman/ffmpeg4discord",
+    )
+    parser.add_argument("filename", help="The file path of the file that you wish to compress.", required=True)
+    parser.add_argument(
+        "-o",
+        "--output-dir",
+        default="",
+        help="The desired output directory where the file will land.",
+    )
+    parser.add_argument(
+        "-s",
+        "--target-filesize",
+        default=25,
+        type=float,
+        help="The output file size in MB.",
+    )
+    parser.add_argument("-a", "--audio-br", type=float, default=96, help="Audio bitrate in kbps.")
+
+    # video filters
+    parser.add_argument("-x", "--crop", default="", help="Cropping dimensions. Example: 255x0x1410x1080")
+    parser.add_argument("-r", "--resolution", default="", help="The output resolution of your final video.")
+
+    # configuraiton json file
+    parser.add_argument("--config", help="JSON file containing the run's configuration")
+
+    # web
+    parser.add_argument("--web", action=BooleanOptionalAction, help="Launch ffmpeg4discord's Web UI in your browser.")
+    parser.add_argument("-p", "--port", type=int, default=5333, help="Local port for the Flask application.")
+
+    return vars(parser.parse_args())

ffmpeg4discord-0.1.0/ffmpeg4discord/templates/web.html

@@ -0,0 +1,152 @@
+<!doctype html>
+<html lang="en" data-bs-theme="dark">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ffmpeg4discord's Web UI</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN" crossorigin="anonymous">
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.5.0/font/bootstrap-icons.css">
+</head>
+<body>
+    <div class="container">
+        <div class="row mt-3">
+            <div class="alert alert-light" role="alert" {{ "hidden" if alert_hidden else "" }}>
+                <p>{{ alert }}</p>
+                <span class="text-danger">Remember to terminate this server before starting another job.</span>
+            </div>
+        </div>        
+        <div class="row mt-3">
+            <video id="myVideo" preload="auto" controls>
+                <source src="{{ file_url }}" type="video/mp4">
+                Your browser does not support the video tag.
+            </video>
+            <p class="text-muted"><em>Drag the video playhead, and use the buttons below to set the Start and End times.</em></p> 
+        </div>
+        <form id="encodeForm" action="/encode" method="post">
+            <div class="row mb-3">
+                <div class="col">
+                    <button type="button" class="btn btn-outline-primary" onclick="setTime('start')"><span class="bi-skip-start-fill"></span> Set Start Time</button>
+                </div>
+                <div class="col">
+                    <button type="button" class="btn btn-outline-primary" onclick="setTime('end')">Set End Time <span class="bi-skip-end-fill"></span></button>
+                </div>
+            </div>
+            <div class="row mb-3">
+                <div class="col">
+                    <label for="startTime" class="form-label padding-top">Start Time:</label>
+                    <input class="form-range" type="range" name="startTime" id="startTime" min="0" step="1" max="0">
+                    <span id="startTimeLabel">{{ twopass.from_seconds|string + " seconds" if twopass.from_seconds else "0 seconds" }}</span>
+                </div>
+                <div class="col">
+                    <label for="endTime" class="form-label">End Time:</label>
+                    <input class="form-range" type="range" name="endTime" id="endTime" min="0" step="1" max="0">
+                    <span id="endTimeLabel">{{ twopass.to_seconds|string + " seconds" if twopass.to_seconds else twopass.length|string + " seconds" }}</span>
+                </div>
+            </div>
+            <div class="row">
+                <div class="col">
+                    <button type="button" class="btn btn-outline-primary" onclick="selectVideoPart()"><span class="bi-play"></span> Preview Selection</button>
+                </div>
+            </div>
+            <hr />
+            <div class="row mb-3">
+                <h3>Output Parameters</h3>
+                <div class="col">
+                    <label for="resolution" class="form-label">Resolution</label>
+                    <input class="form-control" name="resolution" id="resolution" type="text" value="{{ twopass.resolution }}" />
+                </div>
+                <div class="col">
+                    <label for="target_filesize" class="form-label">Target File Size (MB)</label>
+                    <input class="form-control" name="target_filesize" id="target_filesize" type="text" value="{{ twopass.target_filesize }}" />
+                </div>
+                <div class="col">
+                    <label for="audio_br" class="form-label">Audio Bitrate (kbps)</label>
+                    <input class="form-control" name="audio_br" id="audio_br" type="text" value="{{ twopass.audio_br/1000 }}" />
+                </div>
+                <div class="col">
+                    <label for="crop" class="form-label">Crop</label>
+                    <input class="form-control" name="crop" id="crop" type="text" value="{{ twopass.crop }}" />
+                </div>
+                <div class="col">
+                    <label for="output_dir" class="form-label">Output Directory</label>
+                    <input class="form-control" name="output_dir" id="output_dir" type="text" value="{{ twopass.output_dir }}" />
+                </div>
+            </div>
+            <div class="row mb-3">
+                <div class="col">
+                    <button id="spinButton" onclick="startSpin()" class="submission btn btn-primary btn-lg" type="submit">
+                        <span class="bi-film"></span> Encode
+                    </button>
+                    <span id="spinIcon" class="spinner-border spinner-border-sm" role="status" aria-hidden="true" hidden></span>
+                </div>
+            </div>
+        </form>
+    </div>
+    <script>
+        const video = document.getElementById('myVideo');
+        const startTimeInput = document.getElementById('startTime');
+        const endTimeInput = document.getElementById('endTime');
+        const startTimeLabel = document.getElementById('startTimeLabel');
+        const endTimeLabel = document.getElementById('endTimeLabel');
+
+        video.addEventListener('loadedmetadata', () => {
+            // Set the maximum value of the input elements to the video duration
+            startTimeInput.max = video.duration;
+            endTimeInput.max = video.duration;
+            startTimeInput.value = "{{ twopass.from_seconds if twopass.from_seconds else 0 }}"
+            endTimeInput.value = "{{ twopass.to_seconds if twopass.to_seconds else twopass.length }}"
+        });
+
+        startTimeInput.addEventListener('input', updateStartTimeLabel);
+        endTimeInput.addEventListener('input', updateEndTimeLabel);
+
+        function updateStartTimeLabel() {
+            startTimeLabel.textContent = startTimeInput.value + ' seconds';
+        }
+
+        function updateEndTimeLabel() {
+            endTimeLabel.textContent = endTimeInput.value + ' seconds';
+        }
+
+        function setTime(type) {
+            const currentTime = Math.floor(video.currentTime);
+            
+            if (type === 'start') {
+                startTimeInput.value = currentTime;
+                startTimeLabel.textContent = currentTime + ' seconds';
+            } else if (type === 'end') {
+                endTimeInput.value = currentTime;
+                endTimeLabel.textContent = currentTime + ' seconds';
+            }
+        }
+
+        function selectVideoPart() {
+            const startTime = parseInt(startTimeInput.value);
+            const endTime = parseInt(endTimeInput.value);
+
+            if (!isNaN(startTime) && !isNaN(endTime) && startTime < endTime) {
+                video.currentTime = startTime;
+                video.play();
+
+                setTimeout(() => {
+                    video.pause();
+                    video.currentTime = endTime;
+                }, (endTime - startTime) * 1000);
+            } else {
+                alert('Please enter valid start and end times.');
+            }
+        }
+
+        function startSpin() {
+            // Get the icon element
+            var icon = document.getElementById('spinIcon');
+            icon.hidden = false;
+
+            // Disable the button temporarily to prevent multiple clicks
+            document.getElementById('spinButton').disabled = true;
+            document.getElementById('encodeForm').submit();
+
+        }
+    </script>
+</body>
+</html>

ffmpeg4discord-0.1.0/ffmpeg4discord/twopass.py

@@ -0,0 +1,250 @@
+import ffmpeg
+import math
+import logging
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+
+logging.getLogger().setLevel(logging.INFO)
+
+
+class TwoPass:
+    def __init__(
+        self,
+        filename: Path,
+        target_filesize: float,
+        output_dir: str = "",
+        times: dict = {},
+        audio_br: float = None,
+        codec: str = "libx264",
+        crop: str = "",
+        resolution: str = "",
+        config: str = "",
+    ) -> None:
+        """
+        A Class to resize a video file to a specified MB target.
+        This class utilizes ffmpeg's two-pass encoding technique with the
+        ffmpeg-python wrapper package.
+        https://trac.ffmpeg.org/wiki/Encode/H.264#twopass
+
+        :param filename: video file that needs to be compressed
+        :param output_dir: directory that the new, compressed output is delivered to
+        :param times: dict containing "from" and "to" timestamp keys in the format 00:00:00
+        :param target_filesize: desired file size of the output file, in MB
+        :param audio_br: desired audio bitrate for the output file in kbps
+        :param codec: ffmpeg video codec to use when encoding the file
+        :param crop: coordinates for cropping the video to a different resolution
+        :param resolution: output file's final resolution e.g. 1280x720
+        :param config: json containing values for the above params
+        """
+
+        if config:
+            self.init_from_config(config_file=config)
+        else:
+            self.target_filesize = target_filesize
+            self.crop = crop
+            self.resolution = resolution
+            self.times = times
+            self.audio_br = audio_br
+            self.codec = codec
+
+        self.filename = filename
+        self.fname = filename.name
+        self.split_fname = self.fname.split(".")
+        self.output_dir = output_dir
+
+        self.probe = ffmpeg.probe(filename=filename)
+        self.duration = math.floor(float(self.probe["format"]["duration"]))
+
+        if len(self.probe["streams"]) > 2:
+            logging.warning(
+                "This media file has more than two streams, which could cause errors during the encoding job."
+            )
+
+        for stream in self.probe["streams"]:
+            ix = stream["index"]
+            if stream["codec_type"] == "video":
+                display_aspect_ratio = self.probe["streams"][ix]["display_aspect_ratio"].split(":")
+                self.ratio = int(display_aspect_ratio[0]) / int(display_aspect_ratio[1])
+            elif stream["codec_type"] == "audio":
+                audio_stream = ix
+
+        if not self.audio_br:
+            self.audio_br = float(self.probe["streams"][audio_stream]["bit_rate"])
+        else:
+            self.audio_br = self.audio_br * 1000
+
+        if self.times:
+            if self.times.get("from"):
+                self.times["ss"] = self.times["from"] or "00:00:00"
+                del self.times["from"]
+            else:
+                self.times["ss"] = "00:00:00"
+
+            self.from_seconds = seconds_from_ts_string(self.times["ss"])
+
+            if self.times.get("to"):
+                self.to_seconds = seconds_from_ts_string(self.times["to"])
+                self.length = self.to_seconds - self.from_seconds
+            else:
+                self.length = self.duration - self.from_seconds
+        else:
+            self.time_from_file_name()
+
+        if self.length <= 0:
+            raise Exception(
+                f"""
+                Time Paradox?
+
+                Something is wrong with your clipping times. Use this
+                information to further diagnose the problem:
+
+                - Your video is {self.duration / 60} minutes long
+                - You want to START clipping at {self.times["ss"]}
+                - You want to STOP clipping at {self.times["to"]}
+                """
+            )
+
+    def init_from_config(self, config_file: str) -> None:
+        """
+        Set the Class values from a json file
+        :param config_file: path to a json file containing parameters for TwoPass()
+        """
+        file_path = Path(config_file).resolve()
+        with open(file_path) as f:
+            config = json.load(f)
+        self.__dict__.update(**config)
+
+    def generate_params(self, codec: str):
+        """
+        Create params for the ffmpeg.output() function
+        :param codec: ffmpeg video codec to use during encoding
+        :return: dictionary containing parameters for ffmpeg's first and second pass.
+        """
+        params = {
+            "pass1": {
+                "pass": 1,
+                "f": "null",
+                "vsync": "cfr",  # not sure if this is unique to x264 or not
+                "c:v": codec,
+            },
+            "pass2": {"pass": 2, "b:a": self.audio_br, "c:v": codec},
+        }
+
+        if codec == "libx264":
+            params["pass2"]["c:a"] = "aac"
+
+        params["pass1"].update(**self.bitrate_dict)
+        params["pass2"].update(**self.bitrate_dict)
+
+        return params
+
+    def create_bitrate_dict(self) -> None:
+        """
+        Perform the calculation specified in ffmpeg's documentation that generates
+        the video bitrates needed to achieve the target file size
+        """
+        br = math.floor((self.target_filesize * 8192) / self.length - (self.audio_br / 1000)) * 1000
+        self.bitrate_dict = {
+            "b:v": br,
+            "minrate": br * 0.5,
+            "maxrate": br * 1.45,
+            "bufsize": br * 2,
+        }
+
+    def time_from_file_name(self):
+        """
+        Create the -ss and -to fields from a file's name
+        """
+        fname = self.fname
+        startstring = f"{fname[0:2]}:{fname[2:4]}:{fname[4:6]}"
+        endstring = f"{fname[7:9]}:{fname[9:11]}:{fname[11:13]}"
+        times = {}
+
+        try:
+            int(fname[0:6])
+            self.from_seconds = seconds_from_ts_string(startstring)
+            times["ss"] = startstring
+            try:
+                int(fname[11:13])
+                self.to_seconds = seconds_from_ts_string(endstring)
+                length = self.to_seconds - self.from_seconds
+                times["to"] = endstring
+            except:
+                length = self.duration - self.from_seconds
+                self.to_seconds = self.duration
+        except:
+            length = self.duration
+
+        self.length = length
+        self.times = times
+
+    def apply_video_filters(self, video):
+        """
+        Function to apply the crop and resolution parameters to a video object
+        :param video: the ffmpeg video object from the Class's input video file
+        :return: the video object after it has been cropped or resized
+        """
+
+        if self.crop:
+            crop = self.crop.split("x")
+            video = video.crop(x=crop[0], y=crop[1], width=crop[2], height=crop[3])
+            self.ratio = int(crop[2]) / int(crop[3])
+
+        if self.resolution:
+            video = video.filter("scale", self.resolution)
+            x = int(self.resolution.split("x")[0])
+            y = int(self.resolution.split("x")[1])
+            outputratio = x / y
+
+            if self.ratio != outputratio:
+                logging.warning(
+                    """
+                    Your output resolution's aspect ratio does not match the
+                    input resolution's or your croped resolution's aspect ratio.
+                    """
+                )
+
+        return video
+
+    def run(self) -> float:
+        """
+        Perform the CPU-intensive encoding job
+        :return: the output file's size
+        """
+
+        self.output_filename = str(
+            Path(self.output_dir)
+            / ("small_" + self.filename.stem.replace(" ", "_") + datetime.strftime(datetime.now(), "_%Y%m%d%H%M%S.mp4"))
+        )
+
+        # generate run parameters
+        self.create_bitrate_dict()
+        params = self.generate_params(codec=self.codec)
+
+        # separate streams from ffinput
+        ffinput = ffmpeg.input(self.filename, **self.times)
+        video = self.apply_video_filters(ffinput.video)
+        audio = ffinput.audio
+
+        # First Pass
+        ffOutput = ffmpeg.output(video, "pipe:", **params["pass1"])
+        ffOutput = ffOutput.global_args("-loglevel", "quiet", "-stats")
+        print("Performing first pass")
+        std_out, std_err = ffOutput.run(capture_stdout=True)
+
+        # Second Pass
+        ffOutput = ffmpeg.output(video, audio, self.output_filename, **params["pass2"])
+        ffOutput = ffOutput.global_args("-loglevel", "quiet", "-stats")
+        print("\nPerforming second pass")
+        ffOutput.run(overwrite_output=True)
+
+        # save the output file size and return it
+        self.output_filesize = os.path.getsize(self.output_filename) * 0.00000095367432
+
+        return self.output_filesize
+
+
+def seconds_from_ts_string(ts_string: str):
+    return int(ts_string[0:2]) * 60 * 60 + int(ts_string[3:5]) * 60 + int(ts_string[6:8])

ffmpeg4discord-0.1.0/ffmpeg4discord/windows.py

@@ -0,0 +1,101 @@
+import sys
+import os
+from urllib.request import urlretrieve
+import zipfile
+from pathlib import Path
+import shutil
+import logging
+import platform
+
+if platform.system() != "Windows":
+    logging.warning(
+        """
+        THIS SCRIPT IS INTENDED FOR WINDOWS USERS
+
+        If you are running this script on macOS, consider installing ffmpeg with
+        Homebrew: https://formulae.brew.sh/formula/ffmpeg
+
+        If you are running this script on some Linux, learn more about your options
+        to install ffmpeg on its website: https://ffmpeg.org/download.html#build-linux
+        """
+    )
+
+    sys.exit()
+
+logging.getLogger().setLevel(logging.INFO)
+
+path = os.environ.get("PATH", "")
+python_install = Path(sys.executable)
+
+if "WindowsApps" in str(python_install):
+    print("Microsoft Store Python installation detected.")
+    target = Path(sys.executable).parent.parent
+else:
+    print("https://python.org Python installation detected.")
+    target = Path(sys.executable).parent / "Scripts"
+
+target.mkdir(parents=True, exist_ok=True)
+
+if str(target) not in path:
+    logging.warning(
+        """
+        The directory we are installing ffmpeg into is not in your 
+        system's PATH. Windows will not be able to find ffmpeg when 
+        trying to run ffmpeg4discord. Please ensure that you installed 
+        Python with the "Add Python to PATH" option selected.
+        
+        More information: https://docs.python.org/3/using/windows.html#finding-the-python-executable
+        """
+    )
+
+
+def copy_directory_contents(source: Path, target: Path) -> None:
+    source_path = source
+    target_path = target
+
+    # Iterate over files in the source directory
+    for item in source_path.iterdir():
+        # Construct target item path
+        target_item = target_path / item.name
+
+        # If the item is a file, copy it to the target directory
+        if item.is_file():
+            shutil.copy2(item, target_item)
+            print(f"Copied file: {item} -> {target_item}")
+
+
+def download_with_progress(url: str, save_path: str) -> None:
+    def report(block_num, block_size, total_size):
+        downloaded = block_num * block_size
+        downloaded_mb = downloaded / (1024 * 1024)
+        total_size_mb = total_size / (1024 * 1024)
+        progress = min(downloaded / total_size, 1.0)
+        percent = round(progress * 100, 2)
+        print(f"\rDownloaded {downloaded_mb:.2f}/{total_size_mb:.2f} MB ({percent}%)", end="")
+
+    save_dir = Path(save_path).parent
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    urlretrieve(url, save_path, reporthook=report)
+    print("\nDownload complete!")
+
+
+def install() -> None:
+    print("Downloading ffmpeg to ffmpeg.zip...")
+    download_with_progress("https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip", "ffmpeg/ffmpeg.zip")
+
+    print("\nUnzipping ffmpeg.zip...")
+    with zipfile.ZipFile("ffmpeg/ffmpeg.zip", "r") as zip_ref:
+        zip_ref.extractall("ffmpeg/")
+        source = Path(f"ffmpeg/{zip_ref.namelist()[0]}/bin").resolve()
+    print("Done!\n")
+
+    copy_directory_contents(source=source, target=target)
+    shutil.rmtree("ffmpeg/")
+
+    print("\nffmpeg installation complete.")
+    print("\nOpen a new Terminal window and type ffmpeg and hit enter to verify that the installation succeeded.")
+
+
+if __name__ == "__main__":
+    install()

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

@@ -0,0 +1,154 @@
+Metadata-Version: 2.1
+Name: ffmpeg4discord
+Version: 0.1.0
+Summary: A tool to help convert a video file to a target file size.
+Author-email: Zach Fleeman <zfleeman@gmail.com>
+Project-URL: Homepage, https://github.com/zfleeman/ffmpeg4discord
+Project-URL: Issues, https://github.com/zfleeman/ffmpeg4discord/issues
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: Flask==3.0.1
+Requires-Dist: ffmpeg-python==0.2.0
+
+# `ff4d` -- Target File Size Video Compression for Discord with FFmpeg
+This repository houses scripts and applications to assist with compressing a video file to a desired size. 
+
+`ff4d` takes a video file as its input and encodes it to be less than 25MB unless specified otherwise. Discord's free-tier file size sharing limit is 25MB. You can change the file's name in a way that trims the file to a timestamped section. I created this package to share large NVIDIA ShadowPlay clips on Discord quickly, without the need for a visual editor. 
+
+The `TwoPass()` Class showcases a 2-pass encoding methodology for the `ffmpeg-python` library, which is not well-documented on the web. The Class also supports a few FFmpeg video filters, like cropping and resolution scaling. It can be used in a variety of different audio/video workflows.
+
+## Installation and Usage
+
+This package works with Python >= 3.8. For Windows users, ensure that Python is added to your system's PATH.
+
+Install this package with the following command.
+
+```
+pip install ffmpeg4discord
+```
+
+You must first have FFmpeg installed on your system. `ffmpeg` needs to be registered in your PATH. macOS or Linux users can use their favorite package manager to do this, but this process is a little more tricky for Windows users.
+
+### Help for Windows users
+
+After installing this package, Windows users can run this command in a terminal to download the necessary `ffmpeg` binaries:
+
+```
+install-ffmpeg-windows
+```
+
+This will place `ffmpeg.exe`, `ffprobe.exe`, and `ffplay.exe` into the same location as your Python executable.
+
+## Usage
+
+Run the program with:
+
+```
+ff4d cool_clip.mp4
+```
+
+I've had a good time using this command with a Batch file on Windows. Refer to the [Sample Batch File](https://github.com/zfleeman/ffmpeg4discord#sample-batch-file) section for more information.
+
+### File name formatting
+1) `000020.mp4`
+    - This clips and compresses the video from 00:00:20 to the end of the clip.
+2) `000020-000145.mp4`
+    - This clips and compresses the video from 00:00:20 to 00:01:45.
+3) `SomethingElse.mp4`
+    - Compresses the entire video if the first six characters of the file's name aren't numeric.
+
+### Optional Arguments
+- `-o`, `--output`
+  - default: the current working directory
+  - If there is a folder that you want all of your smaller clips to land in, specify it with this argument.
+- `-s`, `--filesize`
+  - default: `25.0`
+  - Increase or decrease this value if you want to compress your video to something other than the 8MB Discord limit.
+- `-a`, `--audio-br`
+  - You can change this value if you want to increase or decrease your audio bitrate. Lowering it will allow for a slight increase in the compressed file's video bitrate.
+- `-r`, `--resolution`
+  - Example: `1280x720`
+  - Modify this value to change the output resolution of your video file. I'd recommend lowering your output resolution by 1.5x or 2x. Example: `1920x1080` video should get an output resolution of `1280x720`
+- `-x`, `--crop`
+  - Example: `255x0x1410x1080`
+  - From the top-left of your video, this example goes 255 pixels to the right, 0 pixels down, and it carves out a 1410x1080 section of the video.
+  - [FFmpeg crop documentation](https://ffmpeg.org/ffmpeg-filters.html#Examples-61)
+- `--web`
+  - A Boolean flag. No value is needed after the flag. See [Web UI](#web-ui) for more information on the Web UI.
+- `--config`
+  - Example: `custom_run_config.json`
+  - Path to a json file containing the configuration for the above parameters. This config file takes precedence over all of the other flags.
+
+### JSON Configuration
+If your encoding job will always be the same, you can reference a JSON configuration file instead of passing a long list of arguments to the command line.
+
+```
+{
+    "target_filesize": 8.0,
+    "audio_br": 96,
+    "crop": "",
+    "resolution": "",
+    "codec": "libx264",
+    "times": {
+        "from": "00:00:00",
+        "to": "00:00:40"
+    }
+}
+```
+
+Notes:
+- All of the keys except for `"from"` and `"to"` must always be present. Those entries can be deleted if you do not have a timestamp entry for the given field. Examples: 
+  - `"times": {}` -> if you do not wish to trim the start and stop time of the file. This falls back to the [file name formatting](https://github.com/zfleeman/ffmpeg4discord#file-name-formatting).
+  - `"times": {"from": "00:00:10"}` -> trim the clip from `00:00:10` to the end of the file
+  - `"times": {"to": "00:00:20"}` -> trim the clip from the beginning of the file up to `00:00:20`
+- You can set `audio_br` to `null` if you want to maintain the clip's audio bitrate.
+
+## Detailed Example
+
+```
+ff4d 000050-000145.mp4 \
+    -c 1280x0x2560x1440 \
+    -r 1920x1080 \
+    -s 50 \
+    -a 48 \
+    -o D:/shadowplay/
+```
+
+The example above takes a 5120x1440 resolution video as its input. The script trims the video from 00:00:50 to 00:01:45 (specified in the [file name](https://github.com/zfleeman/ffmpeg4discord#file-name-formatting)). It crops a 2560x1440 section starting at 1280 pixels from the top-left and 0 pixels down (`-c`). The output file will be located in `D:/shadowplay/` (`-o`) with a new resolution of 1920x1080 (`-r`), and it will be 50MB (`-s`). The audio bitrate will be reduced to 48k (`-a`) as well, but that's probably going to sound terrible.
+
+![](https://i.imgur.com/WJXA723.png)
+
+## Web UI
+
+The web UI can be activated by adding `--web` to your `ff4d` call.
+
+```
+ff4d cool_clip.mp4 -r 1280x720 -s 20 --web
+```
+
+That command will spin up a Flask server on your local machine and launch a rendered webpage with the video as the centerpiece. The flags you provide to `ff4d` will fill in the defaults for the form. You can override/replace the values.
+
+You can drag the video playhead to different portions of the video and click the "Set Start/End Time" buttons to specify the section of the video you want to be clipped out. You can also use the range sliders underneath the buttons if you prefer. A "Preview Selection" button is provided for your convenience, and it does what it sounds like.
+
+https://github.com/zfleeman/ffmpeg4discord/assets/1808564/ff323bcb-4747-437b-808f-ce48b8c269ce
+
+The Flask server doesn't automatically stop itself, so you'll have to terminate it manually by closing the terminal it leaves hanging.
+
+## Sample Batch File
+
+To enable "drag and drop" functionality for this package, Windows users can create a `.bat` file with the following code snippet. Once the file is created, you can drag and drop any `.mp4` file on top of it, and it will run with the flags specified in the "[Optional Arguments](https://github.com/zfleeman/ffmpeg4discord#file-name-formatting)" section. This example is a Batch file that will launch the web UI.
+
+```batch
+@echo off
+Set filename=%1
+ff4d %filename% -o "C:/output/folder/" --web
+DEL "ffmpeg2*"
+PAUSE
+```
+
+## Thanks!
+
+Yes, this is a simple collection of Python files using FFmpeg tricks that is masquerading as a robust Audio/Video tool. But! I use this nearly every day to quickly share videos with people on various messaging apps that have built-in video players. I don't have to share a link that embeds a video player this way, and I guess that's important to me?
+
+I like working on this! Enjoy!

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

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+ffmpeg4discord/__init__.py
+ffmpeg4discord/app.py
+ffmpeg4discord/arguments.py
+ffmpeg4discord/twopass.py
+ffmpeg4discord/windows.py
+ffmpeg4discord.egg-info/PKG-INFO
+ffmpeg4discord.egg-info/SOURCES.txt
+ffmpeg4discord.egg-info/dependency_links.txt
+ffmpeg4discord.egg-info/entry_points.txt
+ffmpeg4discord.egg-info/requires.txt
+ffmpeg4discord.egg-info/top_level.txt
+ffmpeg4discord/templates/web.html
+tests/test_twopass.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,3 @@
+[console_scripts]
+ff4d = ffmpeg4discord.app:main
+install-ffmpeg-windows = ffmpeg4discord.windows:install

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

@@ -0,0 +1,2 @@
+Flask==3.0.1
+ffmpeg-python==0.2.0

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

@@ -0,0 +1 @@
+ffmpeg4discord

ffmpeg4discord-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ffmpeg4discord"
+version = "0.1.0"
+description = "A tool to help convert a video file to a target file size."
+readme = {file = "README.md", content-type = "text/markdown"}
+authors = [{ name = "Zach Fleeman", email = "zfleeman@gmail.com" }]
+requires-python = ">= 3.8"
+dependencies = [
+    "Flask==3.0.1",
+    "ffmpeg-python==0.2.0"
+]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+]
+
+[project.urls]
+Homepage = "https://github.com/zfleeman/ffmpeg4discord"
+Issues = "https://github.com/zfleeman/ffmpeg4discord/issues"
+
+[project.scripts]
+ff4d = "ffmpeg4discord.app:main"
+install-ffmpeg-windows = "ffmpeg4discord.windows:install"
+
+[tool.setuptools.package-data]
+ffmpeg4discord = ["templates/*.html"]

ffmpeg4discord-0.1.0/setup.cfg

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

ffmpeg4discord-0.1.0/tests/test_twopass.py

@@ -0,0 +1,111 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from ffmpeg4discord.twopass import TwoPass
+from pathlib import Path
+
+
+class TestTwoPass(unittest.TestCase):
+    def setUp(self):
+        self.filename = Path("000100.mp4")
+        self.target_filesize = 50.0  # MB
+
+    @patch("ffmpeg4discord.twopass.ffmpeg.probe")
+    def test_init(self, mock_probe: MagicMock):
+        # Set up mock values for the probe
+        mock_probe.return_value = {
+            "streams": [
+                {"index": 0, "codec_type": "video", "display_aspect_ratio": "16:9"},
+                {"index": 1, "codec_type": "audio", "bit_rate": "128000"},
+            ],
+            "format": {"duration": "3600"},
+        }
+
+        # Create TwoPass instance
+        twopass = TwoPass(self.filename, self.target_filesize)
+
+        # Check attributes
+        self.assertEqual(twopass.filename, self.filename)
+        self.assertEqual(twopass.target_filesize, self.target_filesize)
+        self.assertEqual(twopass.duration, 3600)
+        self.assertEqual(twopass.audio_br, 128000)
+
+    @patch("ffmpeg4discord.twopass.ffmpeg.probe")
+    def test_time_from_file_name(self, mock_probe: MagicMock):
+        # Set up mock values for the probe
+        mock_probe.return_value = {
+            "streams": [
+                {"index": 0, "codec_type": "video", "display_aspect_ratio": "16:9"},
+                {"index": 1, "codec_type": "audio", "bit_rate": "128000"},
+            ],
+            "format": {"duration": "3600"},
+        }
+        # mock_seconds_from_ts_string.return_value = 60
+
+        # Create TwoPass instance
+        twopass = TwoPass(self.filename, self.target_filesize)
+
+        # Call time_from_file_name
+        twopass.time_from_file_name()
+
+        # Check attributes
+        self.assertEqual(twopass.from_seconds, 60)
+        self.assertEqual(twopass.times, {"ss": "00:01:00"})
+
+    @patch("ffmpeg4discord.twopass.ffmpeg.probe")
+    def test_create_bitrate_dict(self, mock_probe: MagicMock):
+        # Set up mock values for the probe
+        mock_probe.return_value = {
+            "streams": [
+                {"index": 0, "codec_type": "video", "display_aspect_ratio": "16:9"},
+                {"index": 1, "codec_type": "audio", "bit_rate": "128000"},
+            ],
+            "format": {"duration": "120"},
+        }
+
+        # Create TwoPass instance
+        twopass = TwoPass(self.filename, self.target_filesize)
+
+        # Call create_bitrate_dict
+        twopass.create_bitrate_dict()
+
+        # Check bitrate_dict attribute
+        self.assertEqual(twopass.bitrate_dict["b:v"], 6698000)
+        self.assertEqual(twopass.bitrate_dict["minrate"], 3349000)
+        self.assertEqual(twopass.bitrate_dict["maxrate"], 9712100)
+        self.assertEqual(twopass.bitrate_dict["bufsize"], 13396000)
+
+    @patch("ffmpeg4discord.twopass.os.path.getsize")
+    @patch("ffmpeg4discord.twopass.ffmpeg.probe")
+    @patch("ffmpeg4discord.twopass.ffmpeg.output")
+    def test_run(self, mock_output: MagicMock, mock_probe: MagicMock, mock_os_path_getsize: MagicMock):
+        # Set up mock values for the probe
+        mock_probe.return_value = {
+            "streams": [
+                {"index": 0, "codec_type": "video", "display_aspect_ratio": "16:9"},
+                {"index": 1, "codec_type": "audio", "bit_rate": "128000"},
+            ],
+            "format": {"duration": "3600"},
+        }
+
+        # Create TwoPass instance
+        twopass = TwoPass(self.filename, self.target_filesize)
+
+        # Mock output.run() to return some values
+        mock_run = MagicMock()
+        mock_run.run.return_value = ("a", "b")
+        mock_output.return_value = mock_run
+        mock_output.return_value.global_args.return_value = mock_run
+
+        # Fake a file size
+        mock_os_path_getsize.return_value = 52428799
+
+        # Call run method
+        result = twopass.run()
+
+        # Check output_filesize attribute and return value
+        self.assertLess(twopass.output_filesize, 50)  # Mocking output file size
+        self.assertLess(result, 50)
+
+
+if __name__ == "__main__":
+    unittest.main()