[video_transcoder] v0.1.2

source/video_transcoder/changelog.md

@@ -1,4 +1,7 @@
 
+**<span style="color:#56adda">0.1.2</span>**
+- Fix for plugin updates from versions older than 0.1.0
+
 **<span style="color:#56adda">0.1.1</span>**
 - Add support for the av1_qsv encoder
 

source/video_transcoder/info.json

@@ -12,5 +12,5 @@
         "on_worker_process": 1
     },
     "tags": "video,ffmpeg",
-    "version": "0.1.1"
+    "version": "0.1.2"
 }

source/video_transcoder/lib/encoders/libx.py

@@ -24,22 +24,23 @@
 
 
 class LibxEncoder:
-    provides = {
-        "libx264": {
-            "codec": "h264",
-            "label": "CPU - libx264",
-        },
-        "libx265": {
-            "codec": "hevc",
-            "label": "CPU - libx265",
-        },
-    }
 
     def __init__(self, settings):
         self.settings = settings
 
-    @staticmethod
-    def options():
+    def provides(self):
+        return {
+            "libx264": {
+                "codec": "h264",
+                "label": "CPU - libx264",
+            },
+            "libx265": {
+                "codec": "hevc",
+                "label": "CPU - libx265",
+            },
+        }
+
+    def options(self):
         return {
             "preset":                     "slow",
             "tune":                       "disabled",
@@ -49,21 +50,18 @@ def options():
             "average_bitrate":            "5",
         }
 
-    @staticmethod
-    def generate_default_args(settings):
+    def generate_default_args(self):
         """
         Generate a list of args for using a libx decoder
 
-        :param settings:
         :return:
         """
         # No default args required
         generic_kwargs = {}
         advanced_kwargs = {}
         return generic_kwargs, advanced_kwargs
 
-    @staticmethod
-    def generate_filtergraphs():
+    def generate_filtergraphs(self):
         """
         Generate the required filter for this encoder
         No filters are required for libx encoders
@@ -73,7 +71,8 @@ def generate_filtergraphs():
         return []
 
     def encoder_details(self, encoder):
-        return self.provides.get(encoder, {})
+        provides = self.provides()
+        return provides.get(encoder, {})
 
     def args(self, stream_id):
         stream_encoding = []

source/video_transcoder/lib/encoders/nvenc.py

@@ -89,22 +89,23 @@ def get_configured_device(settings):
 
 
 class NvencEncoder:
-    provides = {
-        "h264_nvenc": {
-            "codec": "h264",
-            "label": "NVENC - h264_nvenc",
-        },
-        "hevc_nvenc": {
-            "codec": "hevc",
-            "label": "NVENC - hevc_nvenc",
-        },
-    }
 
     def __init__(self, settings):
         self.settings = settings
 
-    @staticmethod
-    def options():
+    def provides(self):
+        return {
+            "h264_nvenc": {
+                "codec": "h264",
+                "label": "NVENC - h264_nvenc",
+            },
+            "hevc_nvenc": {
+                "codec": "hevc",
+                "label": "NVENC - hevc_nvenc",
+            },
+        }
+
+    def options(self):
         return {
             "nvenc_device":                        "none",
             "nvenc_decoding_method":               "cpu",
@@ -118,34 +119,31 @@ def options():
             "nvenc_aq_strength":                   8,
         }
 
-    @staticmethod
-    def generate_default_args(settings):
+    def generate_default_args(self):
         """
         Generate a list of args for using a NVENC decoder
 
         REF: https://trac.ffmpeg.org/wiki/HWAccelIntro#NVDECCUVID
 
-        :param settings:
         :return:
         """
-        hardware_device = get_configured_device(settings)
+        hardware_device = get_configured_device(self.settings)
 
         generic_kwargs = {}
         advanced_kwargs = {}
         # Check if we are using a HW accelerated decoder also
-        if settings.get_setting('nvenc_decoding_method') in ['cuda', 'nvdec', 'cuvid']:
+        if self.settings.get_setting('nvenc_decoding_method') in ['cuda', 'nvdec', 'cuvid']:
             generic_kwargs = {
                 "-hwaccel_device":   hardware_device.get('hwaccel_device'),
-                "-hwaccel":          settings.get_setting('nvenc_decoding_method'),
+                "-hwaccel":          self.settings.get_setting('nvenc_decoding_method'),
                 "-init_hw_device":   "cuda=hw",
                 "-filter_hw_device": "hw",
             }
-            if settings.get_setting('nvenc_decoding_method') in ['cuda', 'nvdec']:
+            if self.settings.get_setting('nvenc_decoding_method') in ['cuda', 'nvdec']:
                 generic_kwargs["-hwaccel_output_format"] = "cuda"
         return generic_kwargs, advanced_kwargs
 
-    @staticmethod
-    def generate_filtergraphs(software_filters, hw_smart_filters):
+    def generate_filtergraphs(self, software_filters, hw_smart_filters):
         """
         Generate the required filter for enabling NVENC HW acceleration
 
@@ -166,7 +164,8 @@ def encoder_details(self, encoder):
         if not hardware_devices:
             # Return no options. No hardware device was found
             return {}
-        return self.provides.get(encoder, {})
+        provides = self.provides()
+        return provides.get(encoder, {})
 
     def args(self, stream_info, stream_id):
         generic_kwargs = {}

source/video_transcoder/lib/encoders/qsv.py

@@ -33,26 +33,27 @@
 
 
 class QsvEncoder:
-    provides = {
-        "h264_qsv": {
-            "codec": "h264",
-            "label": "QSV - h264_qsv",
-        },
-        "hevc_qsv": {
-            "codec": "hevc",
-            "label": "QSV - hevc_qsv",
-        },
-        "av1_qsv":  {
-            "codec": "av1",
-            "label": "QSV - av1_qsv",
-        },
-    }
 
     def __init__(self, settings):
         self.settings = settings
 
-    @staticmethod
-    def options():
+    def provides(self):
+        return {
+            "h264_qsv": {
+                "codec": "h264",
+                "label": "QSV - h264_qsv",
+            },
+            "hevc_qsv": {
+                "codec": "hevc",
+                "label": "QSV - hevc_qsv",
+            },
+            "av1_qsv":  {
+                "codec": "av1",
+                "label": "QSV - av1_qsv",
+            },
+        }
+
+    def options(self):
         return {
             "qsv_decoding_method":            "cpu",
             "qsv_preset":                     "slow",
@@ -63,8 +64,7 @@ def options():
             "qsv_average_bitrate":            "5",
         }
 
-    @staticmethod
-    def generate_default_args(settings):
+    def generate_default_args(self):
         """
         Generate a list of args for using a QSV decoder
 
@@ -79,7 +79,7 @@ def generate_default_args(settings):
         }
         advanced_kwargs = {}
         # Check if we are using a HW accelerated decoder> Modify args as required
-        if settings.get_setting('qsv_decoding_method') in ['qsv']:
+        if self.settings.get_setting('qsv_decoding_method') in ['qsv']:
             generic_kwargs = {
                 "-hwaccel":               "qsv",
                 "-hwaccel_output_format": "qsv",
@@ -88,8 +88,7 @@ def generate_default_args(settings):
             }
         return generic_kwargs, advanced_kwargs
 
-    @staticmethod
-    def generate_filtergraphs(settings, software_filters, hw_smart_filters):
+    def generate_filtergraphs(self, settings, software_filters, hw_smart_filters):
         """
         Generate the required filter for enabling QSV HW acceleration
 
@@ -117,7 +116,8 @@ def generate_filtergraphs(settings, software_filters, hw_smart_filters):
         return generic_kwargs, advanced_kwargs, filter_args
 
     def encoder_details(self, encoder):
-        return self.provides.get(encoder, {})
+        provides = self.provides()
+        return provides.get(encoder, {})
 
     def args(self, stream_id):
         stream_encoding = []

source/video_transcoder/lib/encoders/vaapi.py

@@ -47,22 +47,23 @@ def list_available_vaapi_devices():
 
 
 class VaapiEncoder:
-    provides = {
-        "h264_vaapi": {
-            "codec": "h264",
-            "label": "VAAPI - h264_vaapi",
-        },
-        "hevc_vaapi": {
-            "codec": "hevc",
-            "label": "VAAPI - hevc_vaapi",
-        },
-    }
 
     def __init__(self, settings):
         self.settings = settings
 
-    @staticmethod
-    def options():
+    def provides(self):
+        return {
+            "h264_vaapi": {
+                "codec": "h264",
+                "label": "VAAPI - h264_vaapi",
+            },
+            "hevc_vaapi": {
+                "codec": "hevc",
+                "label": "VAAPI - hevc_vaapi",
+            },
+        }
+
+    def options(self):
         return {
             "vaapi_device":                     "none",
             "vaapi_enabled_hw_decoding":        True,
@@ -72,12 +73,10 @@ def options():
             "vaapi_average_bitrate":            "5",
         }
 
-    @staticmethod
-    def generate_default_args(settings):
+    def generate_default_args(self):
         """
         Generate a list of args for using a VAAPI decoder
 
-        :param settings:
         :return:
         """
         # Set the hardware device
@@ -88,18 +87,18 @@ def generate_default_args(settings):
 
         hardware_device = None
         # If we have configured a hardware device
-        if settings.get_setting('vaapi_device') not in ['none']:
+        if self.settings.get_setting('vaapi_device') not in ['none']:
             # Attempt to match to that configured hardware device
             for hw_device in hardware_devices:
-                if settings.get_setting('vaapi_device') == hw_device.get('hwaccel_device'):
+                if self.settings.get_setting('vaapi_device') == hw_device.get('hwaccel_device'):
                     hardware_device = hw_device
                     break
         # If no matching hardware device is set, then select the first one
         if not hardware_device:
             hardware_device = hardware_devices[0]
 
         # Check if we are using a VAAPI decoder also...
-        if settings.get_setting('vaapi_enabled_hw_decoding'):
+        if self.settings.get_setting('vaapi_enabled_hw_decoding'):
             # Set a named global device that can be used with various params
             dev_id = 'vaapi0'
             # Configure args such that when the input may or may not be able to be decoded with hardware we can do:
@@ -123,8 +122,7 @@ def generate_default_args(settings):
 
         return generic_kwargs, advanced_kwargs
 
-    @staticmethod
-    def generate_filtergraphs():
+    def generate_filtergraphs(self):
         """
         Generate the required filter for enabling VAAPI HW acceleration
 
@@ -133,7 +131,8 @@ def generate_filtergraphs():
         return ["format=nv12|vaapi,hwupload"]
 
     def encoder_details(self, encoder):
-        return self.provides.get(encoder, {})
+        provides = self.provides()
+        return provides.get(encoder, {})
 
     def args(self, stream_id):
         stream_encoding = []

source/video_transcoder/lib/global_settings.py

@@ -97,19 +97,6 @@ def __set_default_option(self, select_options, key, default_option=None):
         if self.settings.get_setting(key) not in available_options:
             self.settings.set_setting(key, default_option)
 
-    @staticmethod
-    def __is_nvidia_gpu_present():
-        try:
-            # Run the nvidia-smi command
-            subprocess.run("nvidia-smi", stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
-            return True
-        except FileNotFoundError:
-            # nvidia-smi executable not found
-            return False
-        except subprocess.CalledProcessError:
-            # nvidia-smi command failed, likely no NVIDIA GPU present
-            return False
-
     def get_mode_form_settings(self):
         return {
             "label":          "Config mode",