#1765 simplify decoder interface

use options typedict for flags and pixel format

Author: totaam

tests/unittests/unit/codecs/color_range_test.py

@@ -175,7 +175,8 @@ def verify_rgb(self, enc_name: str, encoding: str, image: ImageWrapper, enc_opti
             # print(f"testing {fmt} rgb decoding using {decompress_to_rgb}")
             if not decompress_to_rgb:
                 continue
-            rimage = decompress_to_rgb(self.rgb_format, data)
+            dec_options = typedict({"rgb_format": self.rgb_format})
+            rimage = decompress_to_rgb(data, dec_options)
             tolerance = enc_options["tolerance"]
             if dec_name == "dec_jpeg":
                 tolerance += 1

xpra/client/gui/window_backing_base.py

@@ -506,17 +506,10 @@ def nv_decode(self, encoding: str, img_data, width: int, height: int, options: t
 
     def do_paint_jpeg(self, encoding: str, img_data, x: int, y: int, width: int, height: int,
                       options: typedict, callbacks: PaintCallbacks) -> None:
-        alpha_offset = options.intget("alpha-offset", 0)
         img = self.nv_decode(encoding, img_data, width, height, options)
         if img is None:
-            if encoding == "jpeg":
-                rgb_format = "BGRX"
-            elif encoding == "jpega":
-                rgb_format = "BGRA"
-            else:
-                raise ValueError(f"invalid encoding {encoding!r}")
             assert self.jpeg_decoder is not None
-            img = self.jpeg_decoder.decompress_to_rgb(rgb_format, img_data, alpha_offset)
+            img = self.jpeg_decoder.decompress_to_rgb(img_data, options)
         self.paint_image_wrapper(encoding, img, x, y, width, height, options, callbacks)
 
     def paint_avif(self, img_data, x: int, y: int, width: int, height: int,
@@ -549,9 +542,7 @@ def paint_webp(self, img_data, x: int, y: int, width: int, height: int,
             img = self.webp_decoder.decompress_to_yuv(img_data, options, has_alpha)
             self.paint_image_wrapper("webp", img, x, y, width, height, options, callbacks)
             return
-        rgb_format = options.strget("rgb_format", "BGRX")
-        has_alpha = options.boolget("has_alpha", False)
-        img = self.webp_decoder.decompress_to_rgb(rgb_format, img_data, has_alpha)
+        img = self.webp_decoder.decompress_to_rgb(img_data, options)
         self.paint_image_wrapper("webp", img, x, y, width, height, options, callbacks)
 
     def paint_rgb(self, rgb_format: str, raw_data, x: int, y: int, width: int, height: int, rowstride: int,

xpra/codecs/jpeg/decoder.pyx

@@ -228,7 +228,11 @@ def decompress_to_yuv(data: bytes, options: typedict, unsigned char nplanes=3) -
     return ImageWrapper(0, 0, w, h, pyplanes, pixel_format, 24, pystrides, planes=ImageWrapper.PLANAR_3)
 
 
-def decompress_to_rgb(rgb_format: str, data: bytes, unsigned long alpha_offset=0) -> ImageWrapper:
+def decompress_to_rgb(data: bytes, options: typedict) -> ImageWrapper:
+    cdef unsigned int alpha_offset = options.intget("alpha-offset", 0)
+    rgb_format = "BGRA" if alpha_offset else "BGRX"
+
+    rgb_format = options.strget("rgb_format", "BGRX")
     assert rgb_format in TJPF_VAL
     cdef TJPF pixel_format = TJPF_VAL[rgb_format]
 
@@ -337,7 +341,7 @@ def selftest(full=False) -> None:
     log("jpeg selftest")
 
     def test_rgbx(bdata):
-        return decompress_to_rgb("RGBX", bdata)
+        return decompress_to_rgb(bdata, typedict())
 
     def test_yuv(bdata):
         return decompress_to_yuv(bdata, typedict())

xpra/codecs/webp/decoder.pyx

@@ -175,9 +175,11 @@ cdef inline int roundup(int n, int m):
     return (n + m - 1) & ~(m - 1)
 
 
-def decompress_to_rgb(rgb_format: str, data: bytes, has_alpha: bool=True) -> ImageWrapper:
+def decompress_to_rgb(data: bytes, options: typedict) -> ImageWrapper:
+    cdef int has_alpha = options.boolget("has_alpha", False)
+    rgb_format = options.strget("rgb_format", "BGRA" if has_alpha else "BGRX")
     if rgb_format not in ("RGBX", "RGBA", "BGRA", "BGRX", "RGB", "BGR"):
-        raise ValueError(f"unsupported rgb format {rgb_format}")
+        raise ValueError(f"unsupported rgb format {rgb_format!r}")
     cdef WebPDecoderConfig config
     config.options.use_threads = 1
     WebPInitDecoderConfig(&config)
@@ -236,7 +238,7 @@ class WebpImageWrapper(ImageWrapper):
             free(<void *> buf)
 
 
-def decompress_to_yuv(data: bytes, options: typedict, has_alpha=False) -> WebpImageWrapper:
+def decompress_to_yuv(data: bytes, options: typedict) -> WebpImageWrapper:
     """
         This returns a WebpBufferWrapper, you MUST call free() on it
         once the pixel buffer can be freed.
@@ -248,6 +250,7 @@ def decompress_to_yuv(data: bytes, options: typedict, has_alpha=False) -> WebpIm
     log("webp decompress_to_yuv found features: width=%4i, height=%4i, has_alpha=%-5s", config.input.width, config.input.height, bool(config.input.has_alpha))
 
     config.output.colorspace = MODE_YUV
+    cdef int has_alpha = options.boolget("has_alpha", False)
     cdef int alpha = has_alpha and config.input.has_alpha
     if alpha:
         log.warn("Warning: webp YUVA colorspace not supported yet")
@@ -325,14 +328,20 @@ def selftest(full=False) -> None:
     for size, samples in TEST_PICTURES["webp"].items():
         w, h = size
         for bdata in samples:
-            for alpha in (True, False):
-                rgb_format = "BGRA" if alpha else "BGRX"
-                img = decompress_to_rgb(rgb_format, bdata, alpha)
-                assert img.get_width()==w and img.get_height()==h and (img.get_pixel_format().find("A")>=0) == alpha
+            for alpha in (False, True):
+                options = typedict({"has_alpha": alpha})
+                img = decompress_to_rgb(bdata, options)
+                iw = img.get_width()
+                ih = img.get_height()
+                pf = img.get_pixel_format()
+                got_alpha = pf.find("A") >= 0
+                assert iw==w and ih==h, f"expected {w}x{h} but got {iw}x{ih}"
+                if not alpha:
+                    assert not got_alpha, f"expected {alpha=}, got {pf}"
                 assert len(img.get_pixels())>0
                 img.free()
 
-            img = decompress_to_yuv(bdata, typedict(), False)
+            img = decompress_to_yuv(bdata, typedict())
             assert img.get_width()==w and img.get_height()==h and (img.get_pixel_format() == "YUV420P")
             assert len(img.get_pixels())>0
             img.free()

xpra/opengl/backing.py

@@ -93,6 +93,11 @@
 
 CURSOR_IDLE_TIMEOUT: int = envint("XPRA_CURSOR_IDLE_TIMEOUT", 6)
 
+PLANAR_FORMATS = (
+    "YUV420P", "YUV422P", "YUV444P", "NV12", "YUV444P16",
+    "GBRP", "GBRP16",
+)
+
 PIXEL_FORMAT_TO_CONSTANT: dict[str, IntConstant] = {
     "r210": GL_BGRA,
     "R210": GL_RGBA,
@@ -1137,13 +1142,8 @@ def paint_nvdec(gl_context) -> None:
                 return
         if JPEG_YUV and width >= 2 and height >= 2 and encoding == "jpeg":
             img = self.jpeg_decoder.decompress_to_yuv(img_data, options)
-        elif encoding == "jpeg":
-            img = self.jpeg_decoder.decompress_to_rgb("BGRX", img_data)
-        elif encoding == "jpega":
-            alpha_offset = options.intget("alpha-offset", 0)
-            img = self.jpeg_decoder.decompress_to_rgb("BGRA", img_data, alpha_offset)
         else:
-            raise ValueError(f"invalid encoding {encoding}")
+            img = self.jpeg_decoder.decompress_to_rgb(img_data, options)
         self.paint_image_wrapper(encoding, img, x, y, width, height, options, callbacks)
 
     def cuda_buffer_to_pbo(self, gl_context, cuda_buffer, rowstride: int, src_y: int, height: int, stream):
@@ -1403,7 +1403,7 @@ def paint_planar(self, context, shader: str, encoding: str, img,
                      x: int, y: int, enc_width: int, enc_height: int, width: int, height: int,
                      options: typedict, callbacks: PaintCallbacks) -> None:
         pixel_format = img.get_pixel_format()
-        if pixel_format not in ("YUV420P", "YUV422P", "YUV444P", "GBRP", "NV12", "GBRP16", "YUV444P16"):
+        if pixel_format not in PLANAR_FORMATS:
             img.free()
             raise ValueError(f"the GL backing does not handle pixel format {pixel_format!r} yet!")
         if not context: