Refactor part of the black bar filter to use HW accel - kept optional

Unfortunately, this did not actually make the process faster. In fact, it made it slower most of the time. So I have decided to leave it disabled for now.

Author: Josh5

changelog.md

@@ -4,6 +4,7 @@
 - Fixed an issue with default tune options on libx264 and libx265
 - Removed the tune option from QSV encoders (not supported).
 - Changed the VAAPI hardware decoding setting to now be a dropdown menu instead of a checkbox (like all the other encoders).
+- Speed up crop-detect on smaller files.
 
 **<span style="color:#56adda">0.1.11</span>**
 - Fix CQP quality selector for VAAPI encoding

lib/encoders/base.py

@@ -1,11 +1,22 @@
 #!/usr/bin/env python3
 # -*- coding:utf-8 -*-
+import logging
+
+logger = logging.getLogger("Unmanic.Plugin.video_transcoder")
+
 
 class Encoder:
-    def __init__(self, settings, probe=None):
+    def __init__(self, settings=None, probe=None):
         self.settings = settings
         self.probe = probe
 
+    def set_probe(self, probe=None, probe_info=None):
+        if isinstance(probe_info, dict):
+            from video_transcoder.lib.ffmpeg import Probe
+            probe = Probe(logger, allowed_mimetypes=['video'])
+            probe.set_probe(probe_info)
+        self.probe = probe
+
     def _target_pix_fmt_for_encoder(self, encoder_name: str) -> str:
         """
         Determines the target pixel format for a given encoder based on the source pixel format.
@@ -96,7 +107,6 @@ def _target_color_config_for_encoder(self, encoder_name: str):
             "color_tags":          color_tags,
             "stream_color_params": stream_color_params,
         }
-        print(result)
         # TODO: Check if we need this
         # result.update(encoder_config)
         return result

lib/encoders/libsvtav1.py

@@ -25,8 +25,8 @@
 
 
 class LibsvtAv1Encoder(Encoder):
-    def __init__(self, settings, probe=None):
-        super().__init__(settings, probe=probe)
+    def __init__(self, settings=None, probe=None):
+        super().__init__(settings=settings, probe=probe)
 
     def provides(self):
         return {

lib/encoders/libx.py

@@ -25,8 +25,8 @@
 
 
 class LibxEncoder(Encoder):
-    def __init__(self, settings, probe=None):
-        super().__init__(settings, probe=probe)
+    def __init__(self, settings=None, probe=None):
+        super().__init__(settings=settings, probe=probe)
 
     def provides(self):
         return {

lib/encoders/nvenc.py

@@ -89,8 +89,8 @@ def get_configured_device(settings):
 
 
 class NvencEncoder(Encoder):
-    def __init__(self, settings, probe=None):
-        super().__init__(settings, probe=probe)
+    def __init__(self, settings=None, probe=None):
+        super().__init__(settings=settings, probe=probe)
 
     def _map_pix_fmt(self, is_h264: bool, is_10bit: bool) -> str:
         if is_10bit and not is_h264:

lib/encoders/qsv.py

@@ -35,8 +35,8 @@
 
 
 class QsvEncoder(Encoder):
-    def __init__(self, settings, probe=None):
-        super().__init__(settings, probe=probe)
+    def __init__(self, settings=None, probe=None):
+        super().__init__(settings=settings, probe=probe)
 
     def _map_pix_fmt(self, is_h264: bool, is_10bit: bool) -> str:
         if is_10bit and not is_h264:
@@ -79,17 +79,15 @@ def generate_default_args(self):
         # Encode only (no decoding)
         #   REF: https://trac.ffmpeg.org/wiki/Hardware/QuickSync#Transcode
         generic_kwargs = {
-            "-init_hw_device":   "qsv=hw",
-            "-filter_hw_device": "hw",
+            "-init_hw_device":   "qsv=qsv0",
+            "-filter_hw_device": "qsv0",
         }
         advanced_kwargs = {}
         # Check if we are using a HW accelerated decoder> Modify args as required
         if self.settings.get_setting('qsv_decoding_method') in ['qsv']:
             generic_kwargs.update({
                 "-hwaccel":               "qsv",
                 "-hwaccel_output_format": "qsv",
-                "-init_hw_device":        "qsv=hw",
-                "-filter_hw_device":      "hw",
             })
         return generic_kwargs, advanced_kwargs
 

lib/encoders/vaapi.py

@@ -49,8 +49,8 @@ def list_available_vaapi_devices():
 
 
 class VaapiEncoder(Encoder):
-    def __init__(self, settings, probe=None):
-        super().__init__(settings, probe=probe)
+    def __init__(self, settings=None, probe=None):
+        super().__init__(settings=settings, probe=probe)
 
     def _map_pix_fmt(self, is_h264: bool, is_10bit: bool) -> str:
         if is_10bit and not is_h264:
@@ -130,10 +130,9 @@ def generate_default_args(self):
                 "-hwaccel":               "vaapi",
                 "-hwaccel_output_format": "vaapi",
                 "-hwaccel_device":        dev_id,
+                "-filter_hw_device":      dev_id,
             }
-            advanced_kwargs = {
-                "-filter_hw_device": dev_id,
-            }
+            advanced_kwargs = {}
         else:
             # Encode only (no decoding)
             #   REF: https://trac.ffmpeg.org/wiki/Hardware/VAAPI#Encode-only (sorta)

lib/global_settings.py

@@ -174,8 +174,8 @@ def get_video_encoder_form_settings(self):
             "input_type":     "select",
             "select_options": [],
         }
-        for encoder_name in self.settings.encoders:
-            encoder_lib = self.settings.encoders.get(encoder_name)
+        encoder_libs = tools.available_encoders(settings=self.settings)
+        for encoder_name, encoder_lib in encoder_libs.items():
             encoder_details = encoder_lib.encoder_details(encoder_name)
             if encoder_details.get('codec') != self.settings.get_setting('video_codec'):
                 continue
@@ -257,6 +257,7 @@ def get_autocrop_black_bars_form_settings(self):
             "description": "Runs FFmpeg 'cropdetect' on the file to auto-detect the crop size.\n"
                            "This detected crop size is then applied during video transcode as a 'crop' filter.",
             "sub_setting": True,
+            "req_lev":     2,
         }
         if not self.settings.get_setting('apply_smart_filters'):
             values["display"] = 'hidden'
@@ -335,6 +336,7 @@ def get_strip_data_streams_form_settings(self):
                            "Certain subtitle formats are stored as data streams in some containers.\n"
                            "Data streams are not supported by all containers.",
             "sub_setting": True,
+            "req_lev":     2,
         }
         if not self.settings.get_setting('apply_smart_filters'):
             values["display"] = 'hidden'
@@ -349,6 +351,7 @@ def get_strip_attachment_streams_form_settings(self):
                            "These streams could contain fonts used in rendering subtitles.\n"
                            "Attachment streams are not supported by all containers.",
             "sub_setting": True,
+            "req_lev":     2,
         }
         if not self.settings.get_setting('apply_smart_filters'):
             values["display"] = 'hidden'

lib/plugin_stream_mapper.py

@@ -89,16 +89,16 @@ def set_default_values(self, settings, abspath, probe):
             if self.settings.get_setting('apply_smart_filters'):
                 if self.settings.get_setting('autocrop_black_bars'):
                     # Test if the file has black bars
-                    self.crop_value = tools.detect_black_bars(abspath, probe.get_probe())
+                    self.crop_value = tools.detect_black_bars(abspath, probe.get_probe(), self.settings)
 
         # Build hardware acceleration args based on encoder
         # Note: these are not applied to advanced mode - advanced mode was returned above
-        for encoder_name in self.settings.encoders:
-            encoder_lib = self.settings.encoders.get(encoder_name)
-            if self.settings.get_setting('video_encoder') in encoder_lib.provides():
-                generic_kwargs, advanced_kwargs = encoder_lib.generate_default_args()
-                self.set_ffmpeg_generic_options(**generic_kwargs)
-                self.set_ffmpeg_advanced_options(**advanced_kwargs)
+        encoder_name = self.settings.get_setting('video_encoder')
+        encoder_lib = tools.available_encoders(settings=self.settings).get(encoder_name)
+        if encoder_lib:
+            generic_kwargs, advanced_kwargs = encoder_lib.generate_default_args()
+            self.set_ffmpeg_generic_options(**generic_kwargs)
+            self.set_ffmpeg_advanced_options(**advanced_kwargs)
 
     def scale_resolution(self, stream_info: dict):
         def get_test_resolution(settings):
@@ -142,7 +142,6 @@ def build_filter_chain(self, stream_info, stream_id):
         :param stream_id:
         :return:
         """
-        filter_id = '0:v:{}'.format(stream_id)
         software_filters = []
         hardware_filters = []
         filter_args = []
@@ -221,21 +220,8 @@ def build_filter_chain(self, stream_info, stream_id):
             return None, None
 
         # Join filtergraph
-        filtergraph = ''
-        count = 1
-        for filter_string in filter_args:
-            # If we are appending to existing filters, separate by a semicolon to start a new chain
-            if filtergraph:
-                filtergraph += ';'
-            # Add the input for this filter
-            filtergraph += '[{}]'.format(filter_id)
-            # Add filtergraph
-            filtergraph += '{}'.format(filter_string)
-            # Update filter ID and add it to the end
-            filter_id = '0:vf:{}-{}'.format(stream_id, count)
-            filtergraph += '[{}]'.format(filter_id)
-            # Increment filter ID counter
-            count += 1
+        filter_id = '0:v:{}'.format(stream_id)
+        filter_id, filtergraph = tools.join_filtergraph(filter_id, filter_args, stream_id)
 
         return filter_id, filtergraph
 

lib/tools.py

@@ -28,6 +28,11 @@
 from collections import Counter
 from typing import List, Optional, Iterable
 
+from video_transcoder.lib.encoders.libx import LibxEncoder
+from video_transcoder.lib.encoders.libsvtav1 import LibsvtAv1Encoder
+from video_transcoder.lib.encoders.qsv import QsvEncoder
+from video_transcoder.lib.encoders.vaapi import VaapiEncoder
+from video_transcoder.lib.encoders.nvenc import NvencEncoder
 from video_transcoder.lib.ffmpeg import StreamMapper
 
 image_video_codecs = [
@@ -114,6 +119,22 @@
 }
 
 
+def available_encoders(settings=None, probe=None):
+    return_encoders = {}
+    encoder_libs = [
+        LibxEncoder,
+        LibsvtAv1Encoder,
+        QsvEncoder,
+        VaapiEncoder,
+        NvencEncoder,
+    ]
+    for encoder_class in encoder_libs:
+        encoder_lib = encoder_class(settings=settings, probe=probe)
+        for encoder in encoder_lib.provides():
+            return_encoders[encoder] = encoder_lib
+    return return_encoders
+
+
 def get_video_stream_data(streams):
     width = 0
     height = 0
@@ -129,7 +150,6 @@ def get_video_stream_data(streams):
     return width, height, video_stream_index
 
 
-
 def format_command_multiline(mapper, max_width=120, indent="  "):
     """
     Prints command for debugging...
@@ -180,7 +200,29 @@ def format_command_multiline(mapper, max_width=120, indent="  "):
     return " \\\n".join(lines)
 
 
-def detect_black_bars(abspath, probe_data):
+def join_filtergraph(filter_id, filter_args, stream_id):
+    """
+    Joins a filtergraph from a collection of args
+    """
+    filtergraph = ''
+    count = 1
+    for filter_string in filter_args:
+        # If we are appending to existing filters, separate by a semicolon to start a new chain
+        if filtergraph:
+            filtergraph += ';'
+        # Add the input for this filter
+        filtergraph += '[{}]'.format(filter_id)
+        # Add filtergraph
+        filtergraph += '{}'.format(filter_string)
+        # Update filter ID and add it to the end
+        filter_id = '0:vf:{}-{}'.format(stream_id, count)
+        filtergraph += '[{}]'.format(filter_id)
+        # Increment filter ID counter
+        count += 1
+    return filter_id, filtergraph
+
+
+def detect_black_bars(abspath, probe_data, settings):
     """
     Detect black bars via ffmpeg cropdetect using quorum logic across multiple samples.
 
@@ -372,17 +414,61 @@ def rdown(v: int, m: int) -> int:
 
         return f"{w_r}:{h_r}:{x_r}:{y_r}"
 
-    def _ffmpeg_sample(ss: int, t_seconds: Optional[int], r_to: Optional[int]) -> str:
+    def _ffmpeg_sample(ss: int, t_seconds: Optional[int], r_to: Optional[int], enable_hw_accel=False) -> str:
+        # NOTE: After adding HW accel, I actually found it to be slower.
+        #   I am leaving the code here with a switch enable_hw_accel incase I come back to test further later on.
         mapper = StreamMapper(logger, ['video', 'audio', 'subtitle', 'data', 'attachment'])
         mapper.set_input_file(abspath)
+
+        # Figure out which video stream we're filtering
+        _, _, video_stream_index = get_video_stream_data(probe_data.get('streams'))
+        # Fallback to 0 if probe didn't return a valid index
+        stream_id = str(video_stream_index if video_stream_index is not None else 0)
+
+        # Configure the cropdetect filter
+        filter_args = [f"cropdetect=mode=black:round={r_to}:reset=0"]
+
+        # Build hardware acceleration args based on encoder
+        # Note: these are not applied to advanced mode - advanced mode was returned above
+        encoder_name = settings.get_setting('video_encoder')
+        encoder_lib = available_encoders(settings=settings).get(encoder_name)
+        if enable_hw_accel and encoder_lib:
+            encoder_lib.set_probe(probe_info=probe_data)
+            generic_kwargs, advanced_kwargs = encoder_lib.generate_default_args()
+            mapper.set_ffmpeg_generic_options(**generic_kwargs)
+            mapper.set_ffmpeg_advanced_options(**advanced_kwargs)
+
+            filtergraph_config = encoder_lib.generate_filtergraphs(
+                filter_args,
+                [],
+                encoder_name
+            )
+
+            generic_kwargs = filtergraph_config.get('generic_kwargs', {})
+            mapper.set_ffmpeg_generic_options(**generic_kwargs)
+
+            advanced_kwargs = filtergraph_config.get('advanced_kwargs', {})
+            mapper.set_ffmpeg_advanced_options(**advanced_kwargs)
+
+            start_filter_args = filtergraph_config.get('start_filter_args', [])
+            end_filter_args = filtergraph_config.get('end_filter_args', [])
+            filter_args = start_filter_args + filter_args + end_filter_args
+
+        # Join filtergraph
+        filter_id = '0:v:{}'.format(stream_id)
+        filter_id, filtergraph = join_filtergraph(filter_id, filter_args, stream_id)
+
         # Seek to the sample start
         mapper.set_ffmpeg_generic_options(**{"-ss": str(int(ss))})
 
-        # Configure time-based cropdetect filter at sample end timestamp
+        # Ingore non-video streams and insert filter
         adv_args = ["-an", "-sn", "-dn"]
-        adv_kwargs = {"-vf": f"cropdetect=round={r_to}:reset=0"}
+        adv_kwargs = {
+            "-filter_complex": filtergraph,
+            "-map":            f"[{filter_id}]",
+        }
         if t_seconds and t_seconds > 0:
-            adv_kwargs["-t"] = str(int(t_seconds))
+            mapper.set_ffmpeg_generic_options(**{"-t": str(int(t_seconds))})
         mapper.set_ffmpeg_advanced_options(*adv_args, **adv_kwargs)
         mapper.set_output_null()
 
@@ -447,14 +533,14 @@ def _quorum(last_three: List[str]) -> Optional[str]:
     logger.info("[BB Detection] Sampling video file '%s' (width:%s, height:%s) to detect black bars",
                 abspath, src_w, src_h)
 
-    # Special case: very short videos (<60s) → single full-file pass
+    # Special case: very short videos (<60s) → single, capped pass (max 20s)
     if total_duration is not None and total_duration < 60:
-        logger.debug("[BB Detection] Duration < 60s. Sampling single full-file pass")
-        observed = _ffmpeg_sample(ss=0, t_seconds=None, r_to=round_to)
-        observed_raw = _ffmpeg_sample(ss=0, t_seconds=None, r_to=round_to)
-
-        logger.debug("[BB Detection] Sample #1 @ 0s → %s", observed)
-        if observed != "NO_CROP":
+        # Cap runtime to avoid slow software decode on whole-file scans
+        t_cap = int(min(20, max(1, total_duration)))
+        logger.debug("[BB Detection] Duration < 60s. Sampling capped to %ss from start (ss=0).", t_cap)
+        observed_raw = _ffmpeg_sample(ss=0, t_seconds=t_cap, r_to=round_to)
+        logger.debug("[BB Detection] Sample #1 @ 0s (t=%ss) → %s", t_cap, observed_raw)
+        if observed_raw != "NO_CROP":
             observed = _normalise_crop_or_nocrop(
                 observed_raw, src_w, src_h,
                 min_sum_tb=12,
@@ -463,8 +549,15 @@ def _quorum(last_three: List[str]) -> Optional[str]:
             if observed == "NO_CROP":
                 logger.debug("[BB Detection] Decision: NO_CROP (normalised from %s).", observed_raw)
                 return None
-            logger.debug("[BB Detection] Decision: CROP=%s.", observed)
+
+            if observed != observed_raw:
+                logger.debug("[BB Detection] Decision: CROP=%s (normalised from %s).", observed, observed_raw)
+            else:
+                logger.debug("[BB Detection] Decision: CROP=%s.", observed)
             return observed
+
+        # observed_raw == NO_CROP
+        logger.debug("[BB Detection] Decision: NO_CROP (short-video capped sample).")
         return None
 
     # Define sampling parameters