better-ffmpeg-progress 2.1.5__tar.gz → 2.1.7__tar.gz

{better-ffmpeg-progress-2.1.5 → better_ffmpeg_progress-2.1.7}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2021 GitHub.com/CrypticSignal
-
-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
+MIT License
+
+Copyright (c) 2021 GitHub.com/CrypticSignal
+
+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.

better_ffmpeg_progress-2.1.7/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.1
+Name: better-ffmpeg-progress
+Version: 2.1.7
+Summary: Run FFmpeg & see percentage progress + ETA.
+Home-page: https://github.com/CrypticSignal/better-ffmpeg-progress
+Author: GitHub.com/CrypticSignal
+Author-email: theaudiophile@outlook.com
+Keywords: ffmpeg,progress
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ffmpeg-python
+Requires-Dist: tqdm
+
+<div align="center">
+
+[![PyPI downloads](https://img.shields.io/pypi/dm/better-ffmpeg-progress?label=PyPI&color=blue)](https://pypistats.org/packages/pypistats)
+[![PyPI downloads](https://img.shields.io/pypi/dw/better-ffmpeg-progress?label=PyPI&color=blue)](https://pypistats.org/packages/pypistats)
+[![GitHub](https://img.shields.io/github/license/crypticsignal/better-ffmpeg-progress?label=License&color=blue)](LICENSE.txt)
+
+# Better FFmpeg Progress
+
+Runs an FFmpeg command and uses [tqdm](https://github.com/tqdm/tqdm) to show a progress bar.
+
+</div>
+
+## Example:
+
+```
+39%|███████████████████████████████████████████ | 23.6/60.2 [00:19<00:34, 1.07s/s]
+```
+
+Where:
+
+- `39%` is the percentage progress.
+- `23.6` seconds of the input file have been processed.
+- `60.2` is the duration of the input file in seconds.
+- `00:19` is the time elapsed since the FFmpeg process started.
+- `00:34` is the estimated time required for the FFmpeg process to complete.
+- `1.07` shows how many seconds of the input file are processed per second.
+
+## Installation:
+
+```
+pip install better-ffmpeg-progress --upgrade
+```
+
+## Usage:
+
+Create an instance of the `FfmpegProcess` class and supply a list of arguments like you would to `subprocess.run()`.
+
+Simple Example:
+
+```py
+from better_ffmpeg_progress import FfmpegProcess
+# Pass a list of FFmpeg arguments, like you would if using subprocess.run()
+process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:a", "libmp3lame", "output.mp3"])
+# Use the run method to run the FFmpeg command.
+process.run()
+```
+
+Advanced Example:
+
+```py
+from better_ffmpeg_progress import FfmpegProcess
+
+def handle_progress_info(percentage, speed, eta, estimated_filesize):
+    print(f"Estimated Output Filesize: {estimated_filesize / 1_000_000} MB")
+
+def handle_success():
+  # Code to run if the FFmpeg process completes successfully.
+  pass
+
+def handle_error():
+  # Code to run if the FFmpeg process encounters an error.
+  pass
+
+# Pass a list of FFmpeg arguments, like you would if using subprocess.run()
+process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:a", "libmp3lame", "output.mp3"])
+
+ffmpeg_output_path = 'ffmpeg_output.txt'
+
+# Use the run method to run the FFmpeg command.
+process.run(progress_handler=handle_progress_info, ffmpeg_output_file=ffmpeg_output_path, success_handler=handle_success, error_handler=handle_error)
+```
+
+The `run` method takes the following **optional** arguments:
+
+- `progress_handler`
+
+  - You can create a function if you would like to do something with the following values:
+
+    - Percentage progress. [float]
+    - Speed, e.g. `22.3x` which means that 22.3 seconds of the input are processed every second. [string]
+    - ETA in seconds. [float]
+    - Estimated output filesize in bytes. [float]
+      - _Note: This is not accurate. Please take the value with a grain of salt._
+
+    The values will be `None` if unknown. The function will receive the aforementioned metrics as arguments, about two times per second.
+
+- `ffmpeg_output_file` - A string path to define where you want the output of FFmpeg to be saved. By default, this is saved in a folder named "ffmpeg_output", with the filename `[<input_filename>].txt`.
+
+- `success_handler` - A function to run if the FFmpeg process completes successfully.
+
+- `error_handler` - A function to run if the FFmpeg process encounters an error.
+
+## Changelog:
+
+[19/09/2022]
+
+- Add the ability to specify a `success_handler` argument, a function to run if the FFmpeg process completes successfully.
+- Add 0.001 to tqdm's `total` parameter to prevent the chance of getting `TqdmWarning: clamping frac to range [0, 1]`
+
+[21/12/2022]
+
+- [v2.0.7] Fix `'estimated_size' referenced before assignment` error.
+- [v2.0.7] The progress bar now uses 1 decimal place for seconds processed and total duration.
+
+[22/12/2022]
+
+- [v2.0.8] Add the ability to specify an `error_handler` argument, a function to run if the FFmpeg process encounters an error.
+- [v2.0.9] Fix a typo (commit [da45a84](https://github.com/CrypticSignal/better-ffmpeg-progress/commit/da45a8416856ab7d3c7b748db5703fa3dbc65f60))
+
+[07/02/2022]
+
+- [v2.1.0] [Update function name](https://github.com/CrypticSignal/better-ffmpeg-progress/commit/572fe8a0d71957d00b833134a4d35170630203fa) to fix `'process_complete_handler' is not defined` error.
+
+[05/11/2023]
+
+- [v2.1.2] [Do not exit the Python interpreter after the FFmpeg process is complete](https://github.com/CrypticSignal/better-ffmpeg-progress/commit/0a358810773835297faae688689c6e0d8a5859ae)
+
+[22/04/2024]
+
+- [v2.1.3] Fix issue [#20](https://github.com/CrypticSignal/better-ffmpeg-progress/issues/20)
+
+[28/04/2024]
+
+- [v2.1.4] Fix issue [#21](https://github.com/CrypticSignal/better-ffmpeg-progress/issues/21)
+
+[02/05/2024]
+
+- [v2.1.5] Fix issue [#23](https://github.com/CrypticSignal/better-ffmpeg-progress/issues/23) and make an error message more specific. [Here](https://github.com/CrypticSignal/better-ffmpeg-progress/commit/a6ef7f26d080b684144021301f3b2aa5e0834dae) is the relevant commit.
+
+[18/10/2024]
+
+- [v2.1.6] Notify the user if the input filepath or filename is incorrect.
+- [v2.1.7] Refactor to use threads and queues.

{better-ffmpeg-progress-2.1.5 → better_ffmpeg_progress-2.1.7}/README.md

@@ -1,122 +1,133 @@
-<div align="center">
-
-[![PyPI downloads](https://img.shields.io/pypi/dm/better-ffmpeg-progress?label=PyPI&color=blue)](https://pypistats.org/packages/pypistats)
-[![PyPI downloads](https://img.shields.io/pypi/dw/better-ffmpeg-progress?label=PyPI&color=blue)](https://pypistats.org/packages/pypistats)
-[![GitHub](https://img.shields.io/github/license/crypticsignal/better-ffmpeg-progress?label=License&color=blue)](LICENSE.txt)
-
-# Better FFmpeg Progress
-
-Runs an FFmpeg command and uses [tqdm](https://github.com/tqdm/tqdm) to show a progress bar.
-
-</div>
-
-## Example:
-
-```
-39%|███████████████████████████████████████████ | 23.6/60.2 [00:19<00:34, 1.07s/s]
-```
-
-Where:
-
-- `39%` is the percentage progress.
-- `23.6` seconds of the input file have been processed.
-- `60.2` is the duration of the input file in seconds.
-- `00:19` is the time elapsed since the FFmpeg process started.
-- `00:34` is the estimated time required for the FFmpeg process to complete.
-- `1.07` shows how many seconds of the input file are processed per second.
-
-## Installation:
-
-`pip3 install better-ffmpeg-progress --upgrade`
-
-## Usage:
-
-Create an instance of the `FfmpegProcess` class and supply a list of arguments like you would to `subprocess.run()`.
-
-Simple Example:
-
-```py
-from better_ffmpeg_progress import FfmpegProcess
-# Pass a list of FFmpeg arguments, like you would if using subprocess.run()
-process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:a", "libmp3lame", "output.mp3"])
-# Use the run method to run the FFmpeg command.
-process.run()
-```
-
-Advanced Example:
-
-```py
-from better_ffmpeg_progress import FfmpegProcess
-
-def handle_progress_info(percentage, speed, eta, estimated_filesize):
-    print(f"Estimated Output Filesize: {estimated_filesize / 1_000_000} MB")
-
-def handle_success():
-  # Code to run if the FFmpeg process completes successfully.
-  pass
-
-def handle_error():
-  # Code to run if the FFmpeg process encounters an error.
-  pass
-
-# Pass a list of FFmpeg arguments, like you would if using subprocess.run()
-process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:a", "libmp3lame", "output.mp3"])
-
-ffmpeg_output_path = 'ffmpeg_output.txt'
-
-# Use the run method to run the FFmpeg command.
-process.run(progress_handler=handle_progress_info, ffmpeg_output_file=ffmpeg_output_path, success_handler=handle_success, error_handler=handle_error)
-```
-
-The `run` method takes the following **optional** arguments:
-
-- `progress_handler`
-
-  - You can create a function if you would like to do something with the following values:
-
-    - Percentage progress. [float]
-    - Speed, e.g. `22.3x` which means that 22.3 seconds of the input are processed every second. [string]
-    - ETA in seconds. [float]
-    - Estimated output filesize in bytes. [float]
-      - _Note: This is not accurate. Please take the value with a grain of salt._
-
-    The values will be `None` if unknown. The function will receive the aforementioned metrics as arguments, about two times per second.
-
-- `ffmpeg_output_file` - A string path to define where you want the output of FFmpeg to be saved. By default, this is saved in a folder named "ffmpeg_output", with the filename `[<input_filename>].txt`.
-
-- `success_handler` - A function to run if the FFmpeg process completes successfully.
-
-- `error_handler` - A function to run if the FFmpeg process encounters an error.
-
-## Changelog:
-
-[19/09/2022]
-
-- Add the ability to specify a `success_handler` argument, a function to run if the FFmpeg process completes successfully.
-- Add 0.001 to tqdm's `total` parameter to prevent the chance of getting `TqdmWarning: clamping frac to range [0, 1]`
-
-[21/12/2022]
-
-- [v2.0.7] Fix `'estimated_size' referenced before assignment` error.
-- [v2.0.7] The progress bar now uses 1 decimal place for seconds processed and total duration.
-
-[22/12/2022]
-
-- [v2.0.8] Add the ability to specify an `error_handler` argument, a function to run if the FFmpeg process encounters an error.
-- [v2.0.9] Fix a typo (commit [da45a84](https://github.com/CrypticSignal/better-ffmpeg-progress/commit/da45a8416856ab7d3c7b748db5703fa3dbc65f60))
-
-[07/02/2022]
-
-- [v2.1.0] [Update function name](https://github.com/CrypticSignal/better-ffmpeg-progress/commit/572fe8a0d71957d00b833134a4d35170630203fa) to fix `'process_complete_handler' is not defined` error.
-
-[05/11/2023]
-
-- [v2.1.2] [Do not exit the Python interpreter after the FFmpeg process is complete](https://github.com/CrypticSignal/better-ffmpeg-progress/commit/0a358810773835297faae688689c6e0d8a5859ae)
-
-[22/04/2024]
-
-- [v2.1.3] Fix issue [#20](https://github.com/CrypticSignal/better-ffmpeg-progress/issues/20)
-
-[28/04/2024]
-
-- [v2.1.4] Fix issue [#21](https://github.com/CrypticSignal/better-ffmpeg-progress/issues/21)
+<div align="center">
+
+[![PyPI downloads](https://img.shields.io/pypi/dm/better-ffmpeg-progress?label=PyPI&color=blue)](https://pypistats.org/packages/pypistats)
+[![PyPI downloads](https://img.shields.io/pypi/dw/better-ffmpeg-progress?label=PyPI&color=blue)](https://pypistats.org/packages/pypistats)
+[![GitHub](https://img.shields.io/github/license/crypticsignal/better-ffmpeg-progress?label=License&color=blue)](LICENSE.txt)
+
+# Better FFmpeg Progress
+
+Runs an FFmpeg command and uses [tqdm](https://github.com/tqdm/tqdm) to show a progress bar.
+
+</div>
+
+## Example:
+
+```
+39%|███████████████████████████████████████████ | 23.6/60.2 [00:19<00:34, 1.07s/s]
+```
+
+Where:
+
+- `39%` is the percentage progress.
+- `23.6` seconds of the input file have been processed.
+- `60.2` is the duration of the input file in seconds.
+- `00:19` is the time elapsed since the FFmpeg process started.
+- `00:34` is the estimated time required for the FFmpeg process to complete.
+- `1.07` shows how many seconds of the input file are processed per second.
+
+## Installation:
+
+```
+pip install better-ffmpeg-progress --upgrade
+```
+
+## Usage:
+
+Create an instance of the `FfmpegProcess` class and supply a list of arguments like you would to `subprocess.run()`.
+
+Simple Example:
+
+```py
+from better_ffmpeg_progress import FfmpegProcess
+# Pass a list of FFmpeg arguments, like you would if using subprocess.run()
+process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:a", "libmp3lame", "output.mp3"])
+# Use the run method to run the FFmpeg command.
+process.run()
+```
+
+Advanced Example:
+
+```py
+from better_ffmpeg_progress import FfmpegProcess
+
+def handle_progress_info(percentage, speed, eta, estimated_filesize):
+    print(f"Estimated Output Filesize: {estimated_filesize / 1_000_000} MB")
+
+def handle_success():
+  # Code to run if the FFmpeg process completes successfully.
+  pass
+
+def handle_error():
+  # Code to run if the FFmpeg process encounters an error.
+  pass
+
+# Pass a list of FFmpeg arguments, like you would if using subprocess.run()
+process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:a", "libmp3lame", "output.mp3"])
+
+ffmpeg_output_path = 'ffmpeg_output.txt'
+
+# Use the run method to run the FFmpeg command.
+process.run(progress_handler=handle_progress_info, ffmpeg_output_file=ffmpeg_output_path, success_handler=handle_success, error_handler=handle_error)
+```
+
+The `run` method takes the following **optional** arguments:
+
+- `progress_handler`
+
+  - You can create a function if you would like to do something with the following values:
+
+    - Percentage progress. [float]
+    - Speed, e.g. `22.3x` which means that 22.3 seconds of the input are processed every second. [string]
+    - ETA in seconds. [float]
+    - Estimated output filesize in bytes. [float]
+      - _Note: This is not accurate. Please take the value with a grain of salt._
+
+    The values will be `None` if unknown. The function will receive the aforementioned metrics as arguments, about two times per second.
+
+- `ffmpeg_output_file` - A string path to define where you want the output of FFmpeg to be saved. By default, this is saved in a folder named "ffmpeg_output", with the filename `[<input_filename>].txt`.
+
+- `success_handler` - A function to run if the FFmpeg process completes successfully.
+
+- `error_handler` - A function to run if the FFmpeg process encounters an error.
+
+## Changelog:
+
+[19/09/2022]
+
+- Add the ability to specify a `success_handler` argument, a function to run if the FFmpeg process completes successfully.
+- Add 0.001 to tqdm's `total` parameter to prevent the chance of getting `TqdmWarning: clamping frac to range [0, 1]`
+
+[21/12/2022]
+
+- [v2.0.7] Fix `'estimated_size' referenced before assignment` error.
+- [v2.0.7] The progress bar now uses 1 decimal place for seconds processed and total duration.
+
+[22/12/2022]
+
+- [v2.0.8] Add the ability to specify an `error_handler` argument, a function to run if the FFmpeg process encounters an error.
+- [v2.0.9] Fix a typo (commit [da45a84](https://github.com/CrypticSignal/better-ffmpeg-progress/commit/da45a8416856ab7d3c7b748db5703fa3dbc65f60))
+
+[07/02/2022]
+
+- [v2.1.0] [Update function name](https://github.com/CrypticSignal/better-ffmpeg-progress/commit/572fe8a0d71957d00b833134a4d35170630203fa) to fix `'process_complete_handler' is not defined` error.
+
+[05/11/2023]
+
+- [v2.1.2] [Do not exit the Python interpreter after the FFmpeg process is complete](https://github.com/CrypticSignal/better-ffmpeg-progress/commit/0a358810773835297faae688689c6e0d8a5859ae)
+
+[22/04/2024]
+
+- [v2.1.3] Fix issue [#20](https://github.com/CrypticSignal/better-ffmpeg-progress/issues/20)
+
+[28/04/2024]
+
+- [v2.1.4] Fix issue [#21](https://github.com/CrypticSignal/better-ffmpeg-progress/issues/21)
+
+[02/05/2024]
+
+- [v2.1.5] Fix issue [#23](https://github.com/CrypticSignal/better-ffmpeg-progress/issues/23) and make an error message more specific. [Here](https://github.com/CrypticSignal/better-ffmpeg-progress/commit/a6ef7f26d080b684144021301f3b2aa5e0834dae) is the relevant commit.
+
+[18/10/2024]
+
+- [v2.1.6] Notify the user if the input filepath or filename is incorrect.
+- [v2.1.7] Refactor to use threads and queues.

{better-ffmpeg-progress-2.1.5 → better_ffmpeg_progress-2.1.7}/better_ffmpeg_progress/__init__.py

@@ -1 +1 @@
-from .better_ffmpeg_progress import FfmpegProcess
+from .better_ffmpeg_progress import FfmpegProcess

better_ffmpeg_progress-2.1.7/better_ffmpeg_progress/better_ffmpeg_progress.py

@@ -0,0 +1,209 @@
+from dataclasses import dataclass
+from pathlib import Path
+from queue import Empty, Queue
+import subprocess
+import sys
+from threading import Thread
+from typing import Callable, List, Optional, Union
+
+from ffmpeg import probe
+from tqdm import tqdm
+
+
+@dataclass
+class FfmpegProgress:
+    """Data class to store FFmpeg progress information."""
+    percentage: float = 0.0
+    speed: float = 0.0
+    eta: Optional[float] = None
+    estimated_size: Optional[int] = None
+
+
+class FfmpegProcess:
+    """
+    Args:
+        command: A list of arguments to pass to FFmpeg.
+        ffmpeg_loglevel: Desired FFmpeg log level. Default is "verbose".
+
+    Raises:
+        FileNotFoundError: If FFmpeg cannot find the input filepath or filename.
+        ValueError: If the list of arguments does not include "-i"
+    """
+
+    WANTED_METRICS = frozenset({"out_time_ms", "total_size", "speed"})
+
+    def __init__(self, command: List[str], ffmpeg_loglevel: str = "verbose"):
+        if "-i" not in command:
+            raise ValueError("FFmpeg command must include '-i'")
+
+        self._ffmpeg_args = command + ["-hide_banner", "-loglevel", ffmpeg_loglevel]
+        self._output_filepath = Path(command[-1])
+        self._progress = FfmpegProgress()
+        self._duration_secs: Optional[float] = None
+        self._current_size: int = 0
+        self._previous_seconds_processed: float = 0
+        self._progress_bar: Optional[tqdm] = None
+        
+        self._get_input_file_duration()
+
+    def _get_input_file_duration(self) -> None:
+        """Use ffprobe to get the duration of the input file"""
+        index_of_filepath = self._ffmpeg_args.index("-i") + 1
+        self._input_filepath = Path(self._ffmpeg_args[index_of_filepath])
+
+        try:
+            self._duration_secs = round(float(probe(self._input_filepath)["format"]["duration"]), 2)
+            print(f"The duration of {self._input_filepath.name} has been detected as {self._duration_secs} seconds")
+            # -progress pipe:1 sends progress metrics to stdout AND -stats_period sets the period at which encoding progress/statistics are updated
+            # -nostats disables encoding progress/statistics in stderr
+            self._ffmpeg_args.extend(["-progress", "pipe:1", "-stats_period", "0.1", "-nostats"])
+        except Exception:
+            print(f"Could not detect the duration of {self._input_filepath.name}. Percentage progress, ETA and estimated filesize will be unavailable.")
+            self._duration_secs = None
+
+    def _check_output_exists(self) -> bool:
+        """Check if output file exists and handle overwrite prompt."""
+        if self._output_filepath.exists() and "-y" not in self._ffmpeg_args:
+            choice = input(f"{self._output_filepath} already exists. Overwrite? [Y/N]: ").lower()
+            if choice != "y":
+                print("FFmpeg process cancelled. Output file exists and overwrite declined.")
+                return False
+            self._ffmpeg_args.insert(1, "-y")
+        return True
+
+    def _update_progress(self, line: str, metric: str, value: str, 
+                        progress_handler: Optional[Callable]) -> None:
+        """Update progress information based on FFmpeg output."""
+        if metric == "total_size":
+            self._current_size = int(value)
+        
+        elif metric == "out_time_ms":
+            seconds_processed = round((int(value) / 1_000_000), 2)
+            
+            if progress_handler is None and self._progress_bar:
+                seconds_increase = seconds_processed - self._previous_seconds_processed
+                self._progress_bar.update(seconds_increase)
+                self._previous_seconds_processed = seconds_processed
+                return
+
+            if self._duration_secs:
+                self._progress.percentage = (seconds_processed / self._duration_secs) * 100
+                if self._current_size and self._progress.percentage > 0:
+                    self._progress.estimated_size = int(self._current_size * (100 / self._progress.percentage))
+
+        elif metric == "speed":
+            speed_str = value.rstrip('x')
+            if speed_str != "0":
+                self._progress.speed = float(speed_str)
+                if self._duration_secs:
+                    seconds_remaining = self._duration_secs - (self._previous_seconds_processed or 0)
+                    self._progress.eta = seconds_remaining / self._progress.speed
+
+        if line == "progress=end":
+            self._progress.percentage = 100
+            self._progress.eta = 0
+
+        if progress_handler:
+            progress_handler(
+                self._progress.percentage,
+                self._progress.speed,
+                self._progress.eta,
+                self._progress.estimated_size
+            )
+
+    @staticmethod
+    def _handle_pipe(pipe, queue: Queue) -> None:
+        """Read from pipe and put lines into queue."""
+        try:
+            for line in pipe:
+                queue.put(line.strip())
+        finally:
+            pipe.close()
+
+    def _write_ffmpeg_output(self, stderr_output: str, output_file: Optional[Union[str, Path]]) -> None:
+        """Write FFmpeg stderr to a txt file."""
+        output_dir = Path("ffmpeg_output")
+        output_dir.mkdir(exist_ok=True)
+        
+        log_file = output_file or output_dir / f"[{self._input_filepath.name}].txt"
+        log_file = Path(log_file)
+        
+        log_file.write_text(stderr_output)
+        print(f"Done! FFmpeg output logged to: {log_file}")
+
+    def run(self, 
+            output_file: Optional[Union[str, Path]] = None,
+            progress_handler: Optional[Callable] = None,
+            success_handler: Optional[Callable] = None,
+            error_handler: Optional[Callable] = None) -> None:
+        """
+        Args:
+            output_file: Optional filepath to write FFmpeg output to
+            progress_handler: Optional function which receives progress metrics
+            success_handler: Optional function to handle successful completion of the FFmpeg process
+            error_handler: Optional function for FFmpeg process error handling
+        """
+        if not self._check_output_exists():
+            return
+
+        print(f"Executing: {' '.join(self._ffmpeg_args)}")
+
+        if self._duration_secs and not progress_handler:
+            self._progress_bar = tqdm(
+                total=self._duration_secs,
+                unit="s",
+                dynamic_ncols=True,
+                leave=False
+            )
+
+        process = subprocess.Popen(
+            self._ffmpeg_args,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+
+        stdout_queue, stderr_queue = Queue(), Queue()
+        # These threads put FFmpeg stdout and stderr into the queues
+        Thread(target=self._handle_pipe, args=(process.stdout, stdout_queue), daemon=True).start()
+        Thread(target=self._handle_pipe, args=(process.stderr, stderr_queue), daemon=True).start()
+
+        stderr_output = []
+
+        try:
+            while process.poll() is None:
+                # Handle stdout (progress metrics are sent here due as we are passing the -progress pipe:1 options to FFmpeg)
+                try:
+                    stdout = stdout_queue.get_nowait()
+                    if stdout:
+                        try:
+                            metric, value = stdout.split("=")
+                            if metric in self.WANTED_METRICS and value and "N/A" not in value:
+                                self._update_progress(stdout, metric, value, progress_handler)
+                        except ValueError:
+                            continue
+                except Empty:
+                    pass
+                # Handle stderr (regular FFmpeg output)
+                try:
+                    stderr = stderr_queue.get_nowait()
+                    if "No such file" in stderr:
+                        raise FileNotFoundError(f"Input file not found: {self._input_filepath}")
+                    stderr_output.append(stderr)
+                except Empty:
+                    pass
+
+            if process.returncode != 0:
+                if error_handler:
+                    error_handler()
+                else:
+                    sys.exit("\nFFmpeg process failed")
+
+            if success_handler:
+                success_handler()
+
+        finally:
+            if self._progress_bar:
+                self._progress_bar.close()
+            
+            self._write_ffmpeg_output("\n".join(stderr_output), output_file)