Add support for automatic HDR10 mapping

Author: Josh5

changelog.md

@@ -1,3 +1,10 @@
+**<span style="color:#56adda">0.1.12</span>**
+- Improved handling for HDR content with new helper tools for detecting and parsing metadata.
+- Removed the look-ahead feature from QSV's HEVC and AV1 encoders (not supported).
+- 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).
+
 **<span style="color:#56adda">0.1.11</span>**
 - Fix CQP quality selector for VAAPI encoding
 

lib/encoders/base.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+# -*- coding:utf-8 -*-
+
+class Encoder:
+    def __init__(self, settings, probe=None):
+        self.settings = settings
+        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.
+        This generic method handles software encoders and calls a specific hardware mapper.
+
+        Args:
+            encoder_name: The name of the FFmpeg encoder (e.g., "hevc_vaapi").
+
+        Returns:
+            The target pixel format string supported by the encoder.
+        """
+        if not self.probe:
+            raise ValueError("Probe not yet specified on Encoder class")
+        src_pix_fmt = self.probe.get_video_stream_pix_fmt()
+        enc = (encoder_name or "").lower()
+        src = (src_pix_fmt or "").lower()
+
+        is_h264 = "h264" in enc
+
+        # Determine bit depth of the source pixel format
+        is_10bit_or_more = any(tag in src for tag in ("10", "12", "p010", "p016"))
+
+        return self._map_pix_fmt(is_h264, is_10bit_or_more)
+
+    def _map_pix_fmt(self, is_h264: bool, is_10bit: bool) -> str:
+        """
+        This method is implemented by child classes to provide the specific
+        pixel format mapping logic. This default implementation handles
+        software formats.
+        """
+        if is_10bit and not is_h264:
+            return "yuv420p10le"
+        else:
+            return "yuv420p"
+
+    def _target_color_config_for_encoder(self, encoder_name: str):
+        """
+        Returns a dict describing how to preserve HDR for the given encoder.
+        This generic method handles common HDR checks and calls a specific
+        mapping method for encoder-specific logic.
+        """
+        if not self.probe:
+            raise ValueError("Probe not yet specified on Encoder class")
+
+        # If the source is not HDR, return early with no changes
+        if not self.probe.is_hdr_source():
+            return {
+                "apply_color_params":  False,
+                "setparams_filter":    None,
+                "color_tags":          {},
+                "stream_color_params": {},
+            }
+
+        # Common pieces for HDR10
+        src_color_tags = self.probe.get_color_tags()
+        color_tags = {
+            "color_primaries": src_color_tags.get("color_primaries", "bt2020"),
+            "color_trc":       src_color_tags.get("color_trc", "smpte2084"),
+            "colorspace":      src_color_tags.get("colorspace", "bt2020nc"),
+            "color_range":     src_color_tags.get("color_range", "tv"),
+        }
+
+        # Build the setparams filter string
+        setparams_filter = (
+            f"setparams="
+            f"range={color_tags['color_range']}:"
+            f"color_primaries={color_tags['color_primaries']}:"
+            f"color_trc={color_tags['color_trc']}:"
+            f"colorspace={color_tags['colorspace']}"
+        )
+
+        # Build the color tags dictionary for output stream
+        stream_color_params = {
+            "-color_primaries": color_tags['color_primaries'],
+            "-color_trc":       color_tags['color_trc'],
+            "-colorspace":      color_tags['colorspace'],
+            "-color_range":     color_tags['color_range'],
+        }
+
+        # Get encoder-specific configuration
+        # TODO: Check if we need this
+        # encoder_config = self._map_color_config_for_encoder(encoder_name, color_tags)
+
+        # Merge the generic and specific configurations
+        result = {
+            "apply_color_params":  True,
+            "setparams_filter":    setparams_filter,
+            "color_tags":          color_tags,
+            "stream_color_params": stream_color_params,
+        }
+        print(result)
+        # TODO: Check if we need this
+        # result.update(encoder_config)
+        return result
+
+    def _map_color_config_for_encoder(self, encoder_name: str, color_tags: dict):
+        """
+        This method must be implemented by a child class to provide the
+        specific HDR configuration for a given encoder.
+
+        Returns a dict containing:
+            "requires_p010": bool,
+            "encoder_args": dict,
+            "bitstream_filter": str|None,
+            "notes": str
+        """
+        raise NotImplementedError("This method must be implemented by a child class.")
+
+    def provides(self):
+        """
+        Returns a dictionary of supported encoder types for a given plugin.
+        Each dictionary entry should contain the codec name and a human-readable label.
+        """
+        raise NotImplementedError("This method must be implemented by a child class.")
+
+    def options(self):
+        """
+        Returns a dictionary of configurable options for the encoder plugin.
+        """
+        raise NotImplementedError("This method must be implemented by a child class.")
+
+    def generate_default_args(self):
+        """
+        Generate a dictionary of default FFmpeg args for the encoder.
+        This method is primarily for hardware encoders to set up the device and context.
+        """
+        raise NotImplementedError("This method must be implemented by a child class.")
+
+    def generate_filtergraphs(self, current_filter_args, smart_filters, encoder_name):
+        """
+        Generate the required filtergraph for the encoder based on the workflow.
+        """
+        raise NotImplementedError("This method must be implemented by a child class.")
+
+    def stream_args(self, stream_info, stream_id, encoder_name):
+        """
+        Generate a list of arguments for the encoder.
+        """
+        raise NotImplementedError("This method must be implemented by a child class.")

lib/encoders/libsvtav1.py

@@ -21,12 +21,12 @@
         If not, see <https://www.gnu.org/licenses/>.
 
 """
+from video_transcoder.lib.encoders.base import Encoder
 
 
-class LibsvtAv1Encoder:
-
-    def __init__(self, settings):
-        self.settings = settings
+class LibsvtAv1Encoder(Encoder):
+    def __init__(self, settings, probe=None):
+        super().__init__(settings, probe=probe)
 
     def provides(self):
         return {
@@ -48,7 +48,7 @@ def options(self):
             "enable_qm":                  False,
             "qm_min":                     "8",
             "encoder_additional_params":  "no_additional_params",
-            "additional_params":           "",
+            "additional_params":          "",
         }
 
     def generate_default_args(self):
@@ -62,20 +62,44 @@ def generate_default_args(self):
         advanced_kwargs = {}
         return generic_kwargs, advanced_kwargs
 
-    def generate_filtergraphs(self):
+    def generate_filtergraphs(self, current_filter_args, smart_filters, encoder_name):
         """
         Generate the required filter for this encoder
-        No filters are required for libx encoders
 
         :return:
         """
-        return []
+        generic_kwargs = {}
+        advanced_kwargs = {}
+        start_filter_args = []
+        end_filter_args = []
+
+        # Check software format to use
+        target_fmt = self._target_pix_fmt_for_encoder(encoder_name)
+
+        # Handle HDR (only for HEVC)
+        target_color_config = self._target_color_config_for_encoder(encoder_name)
+
+        # If we have existing filters:
+        if smart_filters or current_filter_args:
+            start_filter_args.append(f'format={target_fmt}')
+            if target_color_config.get('apply_color_params'):
+                # Apply setparams filter if software filters exist (apply at the start of the filters list) to preserve HDR tags
+                end_filter_args.append(target_color_config['setparams_filter'])
+
+        # Return built args
+        return {
+            "generic_kwargs":    generic_kwargs,
+            "advanced_kwargs":   advanced_kwargs,
+            "smart_filters":     smart_filters,
+            "start_filter_args": start_filter_args,
+            "end_filter_args":   end_filter_args,
+        }
 
     def encoder_details(self, encoder):
         provides = self.provides()
         return provides.get(encoder, {})
 
-    def args(self, stream_id):
+    def stream_args(self, stream_id):
         stream_encoding = []
 
         # Use defaults for basic mode
@@ -90,29 +114,30 @@ def args(self, stream_id):
                 default_crf = 23
             stream_encoding += ['-crf', str(default_crf)]
             return stream_encoding
-        
+
         stav1_params = ["enable-stat-report=1"]
         stav1_params += ['tune=' + str(self.settings.get_setting('tune_stvav1'))]
-        
+
         if self.settings.get_setting('overlays'):
             # Enable overlays
             stav1_params += ['enable-overlays=1']
-            
+
         if self.settings.get_setting('variance_boost'):
             # Enable variance boost
             stav1_params += ['enable-variance-boost=1']
-            
+
         if self.settings.get_setting('enable_qm'):
             # Enable quantization matrix
             stav1_params += ['enable-qm=1']
             stav1_params += ['qm-min=' + str(self.settings.get_setting('qm_min'))]
 
-        if self.settings.get_setting('encoder_additional_params') in ['additional_params'] and len(self.settings.get_setting('encoder_svtav1_additional_params')):
+        if self.settings.get_setting('encoder_additional_params') in ['additional_params'] and len(
+            self.settings.get_setting('encoder_svtav1_additional_params')):
             # Add additional parameters for SVT-AV1
             stav1_params += self.settings.get_setting('encoder_svtav1_additional_params')
-        
+
         stream_encoding += ['-svtav1-params', ":".join(stav1_params)]
-        
+
         # Add the preset
         if self.settings.get_setting('preset'):
             stream_encoding += ['-preset', str(self.settings.get_setting('preset'))]
@@ -221,7 +246,7 @@ def get_constant_quality_scale_form_settings(self):
         if self.settings.get_setting('video_encoder') in ['libsvtav1']:
             values["description"] = "Default value for libsvtav1 = 23"
         return values
-    
+
     def get_video_pix_fmt_form_settings(self):
         values = {
             "label":          "Pixel Format",
@@ -246,7 +271,7 @@ def get_video_pix_fmt_form_settings(self):
         if self.settings.get_setting('mode') not in ['standard']:
             values["display"] = "hidden"
         return values
-    
+
     def get_tune_stvav1_form_settings(self):
         values = {
             "label":          "SVT-AV1: Tune",
@@ -271,7 +296,7 @@ def get_tune_stvav1_form_settings(self):
         if self.settings.get_setting('mode') not in ['standard']:
             values["display"] = "hidden"
         return values
-    
+
     def get_overlays_form_settings(self):
         values = {
             "label":          "SVT-AV1: Enable Overlays",
@@ -282,7 +307,8 @@ def get_overlays_form_settings(self):
                     "value": 0,
                     "label": "No (Default)",
                 },
-                {   "value": 1,
+                {
+                    "value": 1,
                     "label": "Yes"
                 },
             ]
@@ -310,7 +336,7 @@ def get_variance_boost_form_settings(self):
         if self.settings.get_setting('mode') not in ['standard']:
             values["display"] = "hidden"
         return values
-    
+
     def get_enable_qm_form_settings(self):
         values = {
             "label":          "SVT-AV1: Enable Quantization Matrix (enable-qm)",
@@ -348,9 +374,9 @@ def get_qm_min_form_settings(self):
             values["display"] = "hidden"
         if (not self.settings.get_setting('enable_qm')):
             values["display"] = "hidden"
-            
+
         return values
-    
+
     def get_encoder_additional_params_form_settings(self):
         values = {
             "label":          "SVT-AV1: Additional Parameters",
@@ -371,10 +397,10 @@ def get_encoder_additional_params_form_settings(self):
         if self.settings.get_setting('mode') not in ['standard']:
             values["display"] = "hidden"
         return values
-    
+
     def get_additional_params_form_settings(self):
         values = {
-            "label": "SVT-AV1: Additional Parameters field",
+            "label":       "SVT-AV1: Additional Parameters field",
             "description": "Additional SVT-AV1 parameters as a colon-separated string (e.g., enable-cdef=1:enable-restoration=1).",
             "sub_setting": True,
             "input_type":  "textarea",
@@ -383,5 +409,5 @@ def get_additional_params_form_settings(self):
             values["display"] = "hidden"
         if self.settings.get_setting('encoder_additional_params') not in ['additional_params']:
             values["display"] = "hidden"
-        
-        return values
+
+        return values