feat: add progress

Author: slhck

README.md

@@ -57,12 +57,12 @@ Output is to STDOUT so you can redirect that to a file or another script.
 See `ffmpeg-bitrate-stats -h`:
 
 ```
-usage: __main__.py [-h] [-n] [-v] [-s {video,audio}] [-a {time,gop}]
+usage: __main__.py [-h] [-n] [-v] [-q] [-s {video,audio}] [-a {time,gop}]
                    [-c CHUNK_SIZE] [-rs READ_START] [-rd READ_DURATION]
                    [-of {json,csv}] [-p] [-pw PLOT_WIDTH] [-ph PLOT_HEIGHT]
                    input
 
-ffmpeg_bitrate_stats v1.0.2
+ffmpeg_bitrate_stats v1.1.4
 
 positional arguments:
   input                 input file
@@ -72,32 +72,35 @@ options:
   -n, --dry-run         Do not run command, just show what would be done
                         (default: False)
   -v, --verbose         Show verbose output (default: False)
-  -s {video,audio}, --stream-type {video,audio}
+  -q, --quiet           Do not show progress bar (default: False)
+  -s, --stream-type {video,audio}
                         Stream type to analyze (default: video)
-  -a {time,gop}, --aggregation {time,gop}
+  -a, --aggregation {time,gop}
                         Window for aggregating statistics, either time-based
                         (per-second) or per GOP (default: time)
-  -c CHUNK_SIZE, --chunk-size CHUNK_SIZE
+  -c, --chunk-size CHUNK_SIZE
                         Custom aggregation window size in seconds (default:
                         1.0)
-  -rs READ_START, --read-start READ_START
+  -rs, --read-start READ_START
                         Time to wait before sampling video (in HH:MM:SS.msec
                         or seconds) (default: None)
-  -rd READ_DURATION, --read-duration READ_DURATION
+  -rd, --read-duration READ_DURATION
                         Duration for sampling stream (in HH:MM:SS.msec or
                         seconds). Note that seeking is not accurate, see
                         ffprobe documentation on '-read_intervals'. (default:
                         None)
-  -of {json,csv}, --output-format {json,csv}
+  -of, --output-format {json,csv}
                         output in which format (default: json)
   -p, --plot            Plot the bitrate over time (to STDERR) (default:
                         False)
-  -pw PLOT_WIDTH, --plot-width PLOT_WIDTH
+  -pw, --plot-width PLOT_WIDTH
                         Plot width (default: 70)
-  -ph PLOT_HEIGHT, --plot-height PLOT_HEIGHT
+  -ph, --plot-height PLOT_HEIGHT
                         Plot height (default: 18)
 ```
 
+By default, a progress bar is shown during analysis. Use `-q`/`--quiet` to disable it, or `-v`/`--verbose` to show debug output instead.
+
 ## Output
 
 The output can be JSON, which includes individual fields for each chunk, or CSV, which repeats each line for each chunk. The CSV adheres to the “tidy” data concept, so it's a little redundant.

pyproject.toml

@@ -29,6 +29,7 @@ dependencies = [
     "numpy",
     "pandas",
     "plotille",
+    "tqdm",
 ]
 
 [project.urls]

src/ffmpeg_bitrate_stats/__main__.py

@@ -60,6 +60,13 @@ def main() -> None:
         "-v", "--verbose", action="store_true", help="Show verbose output"
     )
 
+    parser.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        help="Do not show progress bar",
+    )
+
     parser.add_argument(
         "-s",
         "--stream-type",
@@ -134,6 +141,9 @@ def main() -> None:
 
     setup_logger(logging.DEBUG if cli_args.verbose else logging.INFO)
 
+    # Show progress by default, but not when quiet or verbose mode is enabled
+    show_progress = not cli_args.quiet and not cli_args.verbose
+
     br = BitrateStats(
         cli_args.input,
         stream_type=cli_args.stream_type,
@@ -142,8 +152,10 @@ def main() -> None:
         read_start=cli_args.read_start,
         read_duration=cli_args.read_duration,
         dry_run=cli_args.dry_run,
+        show_progress=show_progress,
     )
     br.calculate_statistics()
+
     br.print_statistics(cli_args.output_format)
 
     if cli_args.plot:

src/ffmpeg_bitrate_stats/bitrate_stats.py

@@ -10,15 +10,25 @@
 import numpy as np
 import pandas as pd
 import plotille
+from tqdm import tqdm
 
 logger = logging.getLogger("ffmpeg-bitrate-stats")
 
 
 def run_command(
-    cmd: List[str], dry_run: bool = False
+    cmd: List[str],
+    dry_run: bool = False,
+    show_progress: bool = False,
+    total_frames: Optional[int] = None,
 ) -> tuple[str, str] | tuple[None, None]:
     """
     Run a command directly
+
+    Args:
+        cmd: The command to run
+        dry_run: If True, just print the command without running
+        show_progress: If True, show a progress bar
+        total_frames: Total number of frames for progress estimation
     """
 
     # for verbose mode
@@ -29,13 +39,48 @@ def run_command(
         return None, None
 
     process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    stdout, stderr = process.communicate()
+
+    if show_progress:
+        # Read stdout line by line and show progress
+        stdout_lines: List[str] = []
+        packet_count = 0
+
+        # Create progress bar - if we have frame count use it, otherwise use indeterminate
+        pbar = tqdm(
+            total=total_frames,
+            desc="Analyzing",
+            unit=" packets",
+            file=sys.stderr,
+            leave=False,
+        )
+
+        assert process.stdout is not None
+        for line in process.stdout:
+            decoded_line = line.decode("utf-8")
+            stdout_lines.append(decoded_line)
+            # Count packet entries in JSON output
+            if '"pts_time"' in decoded_line or '"size"' in decoded_line:
+                packet_count += 1
+                if total_frames:
+                    pbar.update(1)
+                else:
+                    pbar.update(1)
+                    pbar.total = packet_count
+
+        pbar.close()
+        stdout = "".join(stdout_lines)
+        stderr = process.stderr.read().decode("utf-8") if process.stderr else ""
+        process.wait()
+    else:
+        stdout_bytes, stderr_bytes = process.communicate()
+        stdout = stdout_bytes.decode("utf-8")
+        stderr = stderr_bytes.decode("utf-8")
 
     if process.returncode == 0:
-        return stdout.decode("utf-8"), stderr.decode("utf-8")
+        return stdout, stderr
     else:
         logger.error("error running command: {}".format(" ".join(cmd)))
-        logger.error(stderr.decode("utf-8"))
+        logger.error(stderr)
         sys.exit(1)
 
 
@@ -118,6 +163,7 @@ class BitrateStats:
         read_start (str, optional): Start time for reading in HH:MM:SS.msec or seconds. Defaults to None.
         read_duration (str, optional): Duration for reading in HH:MM:SS.msec or seconds. Defaults to None.
         dry_run (bool, optional): Dry run. Defaults to False.
+        show_progress (bool, optional): Show progress bar. Defaults to True.
     """
 
     def __init__(
@@ -129,6 +175,7 @@ def __init__(
         read_start: Optional[str] = None,
         read_duration: Optional[str] = None,
         dry_run: bool = False,
+        show_progress: bool = True,
     ):
         self.input_file = input_file
 
@@ -154,6 +201,7 @@ def __init__(
             )
 
         self.dry_run = dry_run
+        self.show_progress = show_progress
 
         self.duration: float = 0
         self.fps: float = 0
@@ -189,6 +237,34 @@ def calculate_statistics(self) -> BitrateStatsSummary:
 
         return self.bitrate_stats
 
+    def _get_frame_count(self) -> Optional[int]:
+        """
+        Get the total frame/packet count for progress estimation.
+
+        Returns:
+            int or None: The frame count, or None if unavailable.
+        """
+        cmd = [
+            "ffprobe",
+            "-loglevel",
+            "error",
+            "-select_streams",
+            self.stream_type[0] + ":0",
+            "-show_entries",
+            "stream=nb_frames",
+            "-of",
+            "default=noprint_wrappers=1:nokey=1",
+            self.input_file,
+        ]
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+            if result.returncode == 0 and result.stdout.strip():
+                return int(result.stdout.strip())
+        except (subprocess.TimeoutExpired, ValueError):
+            pass
+        return None
+
     def _calculate_frame_sizes(self) -> list[FrameEntry]:
         """
         Get the frame sizes via ffprobe using the -show_packets option.
@@ -221,7 +297,17 @@ def _calculate_frame_sizes(self) -> list[FrameEntry]:
             ]
         )
 
-        stdout, _ = run_command(base_cmd, self.dry_run)
+        # Get frame count for progress bar (only if showing progress)
+        frame_count = None
+        if self.show_progress:
+            frame_count = self._get_frame_count()
+
+        stdout, _ = run_command(
+            base_cmd,
+            self.dry_run,
+            show_progress=self.show_progress,
+            total_frames=frame_count,
+        )
         if self.dry_run or stdout is None:
             logger.error("Aborting prematurely, dry-run specified or stdout was empty")
             sys.exit(0)