fixate caps to the nearest desired width, height & framerate

Harden the input selection process a bit. The width, height or framerate fields
in a Gst cap could possibly contain non fixated values. For example, framerate
could be a list of fractions (issue #3).

fix: make --input-{width, height, framerate} required with sane defaults
and try to fixate to the neareast of those values.
Now, --input-{width, height, framerate} might not exactly match the chosen
inputs, but at least we'll choose something close to it. Which is what we
usually want anyways.

Author: jashandeep-sohi

webcam_filters/gst.py

@@ -46,9 +46,9 @@
 def add_filters(
     input_dev: str,
     output_dev: str,
-    input_width: t.Optional[int],
-    input_height: t.Optional[int],
-    input_framerate: t.Optional[str],
+    input_width: int,
+    input_height: int,
+    input_framerate: Fraction,
     input_media_type: t.Optional[str],
     background_blur: t.Optional[int],
     selfie_segmentation_model: SelfieSegmentationModel,
@@ -57,48 +57,54 @@ def add_filters(
     """
     Run filters pipeline.
     """
-    src = Gst.ElementFactory.make("v4l2src")
-    src.set_property("device", input_dev)
-    src.set_state(Gst.State.READY)
-    caps = src.get_static_pad("src").query_caps(None)
+    caps = query_device_caps(input_dev)
 
-    src.set_state(Gst.State.NULL)
+    if caps is None:
+        click.echo(f"unable to determine capabilities for device {input_dev!r}")
+        raise click.Abort()
 
     structs = []
-    for c in caps:
-        keep = True
-
-        if input_media_type is not None and input_media_type != c.get_name():
-            keep = False
-
-        if input_width is not None and input_width != c.get_value("width"):
-            keep = False
-
-        if input_height is not None and input_height != c.get_value("height"):
-            keep = False
+    for s in caps:
+        if input_media_type is not None and input_media_type != s.get_name():
+            continue
+
+        s.fixate_field_nearest_int("width", input_width)
+        s.fixate_field_nearest_int("height", input_height)
+        s.fixate_field_nearest_fraction(
+            "framerate",
+            input_framerate.numerator,
+            input_framerate.denominator
+        )
+        structs.append(s)
+
+    if not structs:
+        click.echo("unable to find a suitable input format")
+        raise click.Abort()
+
+    def struct_sort_key(x):
+        _, width = x.get_int("width")
+        _, height = x.get_int("height")
+        _, fr_numerator, fr_denomantor = x.get_fraction("framerate")
+        return (
+            abs(input_width - width),
+            abs(input_height - height),
+            abs(input_framerate - Fraction(fr_numerator, fr_denomantor or 1))
+        )
 
-        if input_framerate is not None:
-            if input_framerate != str(c.get_value("framerate")):
-                keep = False
+    structs = sorted(structs, key=struct_sort_key)
 
-        if keep:
-            structs.append(c)
+    s = structs[0]
+    new_caps = Gst.Caps.new_empty()
+    new_caps.append_structure(s)
 
-    structs = sorted(
-        structs,
-        key=lambda x: (
-            Fraction(str(x.get_value("framerate"))),
-            x.get_value("width"),
-            x.get_value("height"),
-        ),
-        reverse=True
+    click.echo(
+        f"Selectd input: media-type={s.get_name()}, width={s.get_value('width')} "
+        f"height={s.get_value('height')} framerate={s.get_value('framerate')}"
     )
-    new_caps = Gst.Caps.new_empty()
-    for s in structs:
-        new_caps.append_structure(s)
 
     pipeline = Gst.Pipeline.new()
 
+    src = Gst.ElementFactory.make("v4l2src")
     inputfilter = Gst.ElementFactory.make("capsfilter")
     decodebin = Gst.ElementFactory.make("decodebin")
     rgbconvert = Gst.ElementFactory.make("videoconvert")
@@ -108,6 +114,7 @@ def add_filters(
     sinkfilter = Gst.ElementFactory.make("capsfilter")
     sink = Gst.ElementFactory.make("v4l2sink")
 
+    src.set_property("device", input_dev)
     inputfilter.set_property("caps", new_caps)
     rgbfilter.set_property(
         "caps",
@@ -212,32 +219,40 @@ def on_bus_message(
     return True
 
 
-def print_device_caps(
-    ctx: click.Context,
-    param: click.Parameter,
-    value: str,
-) -> None:
-    """
-    Print device capabilities and exit.
-    """
-    if not value or ctx.resilient_parsing:
-        return
-
+def query_device_caps(dev: str) -> t.Optional[Gst.Caps]:
     src = Gst.ElementFactory.make("v4l2src")
-    src.set_property("device", value)
+    src.set_property("device", dev)
 
     src.set_state(Gst.State.READY)
     res = src.get_state(1000)
     pad = src.get_static_pad("src")
 
     if res.state != Gst.State.READY or pad is None:
-        click.echo(f"unable to determine capabilities for device {value!r}")
-        ctx.exit(1)
+        return None
 
     caps = pad.query_caps(None)
     src.set_state(Gst.State.NULL)
 
     if caps.is_any():
+        return None
+
+    return caps
+
+
+def print_device_caps(
+    ctx: click.Context,
+    param: click.Parameter,
+    value: str,
+) -> None:
+    """
+    Print device capabilities and exit.
+    """
+    if not value or ctx.resilient_parsing:
+        return
+
+    caps = query_device_caps(value)
+
+    if caps is None:
         click.echo(f"unable to determine capabilities for device {value!r}")
         ctx.exit(1)
 

webcam_filters/main.py

@@ -1,5 +1,6 @@
 import typing as t
 
+from fractions import Fraction
 from .click import (
     click,
     print_version,
@@ -25,26 +26,27 @@
 )
 @click.option(
     "--input-width",
-    help="Input width.",
+    help="Preferred width.",
     type=int,
-    default=None,
+    default="1280",
 )
 @click.option(
     "--input-height",
-    help="Input height.",
+    help="Preferred height.",
     type=int,
-    default=None,
+    default="720",
 )
 @click.option(
     "--input-framerate",
-    help="Input framerate specified in fractional format (e.g. '30/1').",
-    type=str,
-    default=None,
+    help="Preferred framerate specified in fractional format (e.g. '30/1').",
+    type=Fraction,
+    default="30/1",
 )
 @click.option(
     "--input-media-type",
     help="""
-    Input media type (e.g. 'image/jpeg' or 'x-raw-video').
+    Input media type (e.g. 'image/jpeg' or 'video/x-raw').
+    If specified ONLY that type is allowed. Otherwise, everything is allowed.
     Use --list-dev-caps to see all available formats.
     """,
     type=str,
@@ -120,9 +122,9 @@
 )
 def cli(
     input_dev: str,
-    input_width: t.Optional[int],
-    input_height: t.Optional[int],
-    input_framerate: t.Optional[str],
+    input_width: int,
+    input_height: int,
+    input_framerate: Fraction,
     input_media_type: t.Optional[str],
     output_dev: str,
     background_blur: t.Optional[int],