Ticket #1423: dec_jpeg.patch

xpra/client/gtk2/pixmap_backing.py

@@ -24 +24 @@
     PIXMAP_RGB_MODES += ["BGRX", "BGRA", "BGR"]
 
 
-INTERP_DICT = {"nearest"    : gdk.INTERP_NEAREST,
-               "tiles"      : gdk.INTERP_TILES,
-               "bilinear"   : gdk.INTERP_BILINEAR,
-               "hyper"      : gdk.INTERP_HYPER}
+INTERP_DICT = {
+    "nearest"    : gdk.INTERP_NEAREST,
+    "tiles"      : gdk.INTERP_TILES,
+    "bilinear"   : gdk.INTERP_BILINEAR,
+    "hyper"      : gdk.INTERP_HYPER,
+    }
 SCALING_INTERP_STR = os.environ.get("XPRA_SCALING_INTERPOLATION", "HYPER").lower()
 SCALING_INTERP = INTERP_DICT.get(SCALING_INTERP_STR)
 if not SCALING_INTERP:

xpra/client/window_backing_base.py

@@ -21 +21 @@
 
 DELTA_BUCKETS = envint("XPRA_DELTA_BUCKETS", 5)
 INTEGRITY_HASH = envbool("XPRA_INTEGRITY_HASH", False)
-WEBP_PILLOW = envbool("XPRA_WEBP_PILLOW", False)
 
 #ie:
 #CSC_OPTIONS = { "YUV420P" : {"RGBX" : [swscale.spec], "BGRX" : ...} }
@@ -86 +85 @@
         PIL = get_codec("dec_pillow")
         if PIL:
             self._PIL_encodings = PIL.get_encodings()
+        self.jpeg_decoder = get_codec("dec_jpeg")
         self.draw_needs_refresh = True
         self.mmap = None
         self.mmap_enabled = False
@@ -194 +194 @@
         return rgb_data
 
 
+    def paint_jpeg(self, img_data, x, y, width, height, options, callbacks):
+        image = self.jpeg_decoder.decompress(img_data, width, height, options)
+        log.warn("paint_jpeg: image=%s", image)
+        paint_options = typedict(options)
+        rgb_format = "RGB"
+        paint_options["rgb_format"] = rgb_format
+        self.idle_add(self.do_paint_rgb, rgb_format, image.get_pixels(), x, y, width, height, image.get_rowstride(), paint_options, callbacks)
+
+
     def paint_image(self, coding, img_data, x, y, width, height, options, callbacks):
         """ can be called from any thread """
         #log("paint_image(%s, %s bytes, %s, %s, %s, %s, %s, %s)", coding, len(img_data), x, y, width, height, options, callbacks)
@@ -474 +483 @@
                 self.paint_rgb(rgb_format, img_data, x, y, width, height, rowstride, options, callbacks)
             elif coding in VIDEO_DECODERS:
                 self.paint_with_video_decoder(VIDEO_DECODERS.get(coding), coding, img_data, x, y, width, height, options, callbacks)
+            elif coding=="jpeg" and self.jpeg_decoder:
+                self.paint_jpeg(img_data, x, y, width, height, options, callbacks)
             elif coding in self._PIL_encodings:
                 self.paint_image(coding, img_data, x, y, width, height, options, callbacks)
             elif coding == "scroll":

xpra/codecs/jpeg/__init__.py

@@ +1 @@
+# This file is part of Xpra.
+# Copyright (C) 2017 Antoine Martin <antoine@devloop.org.uk>
+# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
+# later version. See the file COPYING for details.

xpra/codecs/jpeg/decoder.pyx

@@ +1 @@
+# This file is part of Xpra.
+# Copyright (C) 2017 Antoine Martin <antoine@devloop.org.uk>
+# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
+# later version. See the file COPYING for details.
+
+from xpra.log import Logger
+log = Logger("encoder", "jpeg")
+
+from xpra.buffers.membuf cimport getbuf, MemBuf
+from xpra.codecs.image_wrapper import ImageWrapper
+from libc.stdint cimport uint8_t, uint32_t, uintptr_t
+from xpra.buffers.membuf cimport getbuf, MemBuf
+
+
+ctypedef int boolean
+ctypedef unsigned int JDIMENSION
+
+cdef extern from "jpeglib.h":
+    int JPEG_LIB_VERSION
+
+    ctypedef int J_COLOR_SPACE
+    J_COLOR_SPACE JCS_UNKNOWN           # error/unspecified
+    J_COLOR_SPACE JCS_GRAYSCALE         # monochrome
+    J_COLOR_SPACE JCS_RGB               # red/green/blue as specified by the RGB_RED
+                                        # RGB_GREEN, RGB_BLUE, and RGB_PIXELSIZE macros
+    J_COLOR_SPACE JCS_YCbCr             # Y/Cb/Cr (also known as YUV)
+    J_COLOR_SPACE JCS_CMYK              # C/M/Y/K
+    J_COLOR_SPACE JCS_YCCK              # Y/Cb/Cr/K
+    J_COLOR_SPACE JCS_EXT_RGB           # red/green/blue
+    J_COLOR_SPACE JCS_EXT_RGBX          # red/green/blue/x
+    J_COLOR_SPACE JCS_EXT_BGR           # blue/green/red
+    J_COLOR_SPACE JCS_EXT_BGRX          # blue/green/red/x
+    J_COLOR_SPACE JCS_EXT_XBGR          # x/blue/green/red
+    J_COLOR_SPACE JCS_EXT_XRGB          # x/red/green/blue
+    #
+    # When out_color_space it set to JCS_EXT_RGBX, JCS_EXT_BGRX, JCS_EXT_XBGR,
+    # or JCS_EXT_XRGB during decompression, the X byte is undefined, and in
+    # order to ensure the best performance, libjpeg-turbo can set that byte to
+    # whatever value it wishes.  Use the following colorspace constants to
+    # ensure that the X byte is set to 0xFF, so that it can be interpreted as an
+    # opaque alpha channel. */
+    J_COLOR_SPACE JCS_EXT_RGBA          # red/green/blue/alpha
+    J_COLOR_SPACE JCS_EXT_BGRA          # blue/green/red/alpha
+    J_COLOR_SPACE JCS_EXT_ABGR          # alpha/blue/green/red
+    J_COLOR_SPACE JCS_EXT_ARGB          # alpha/red/green/blue
+    J_COLOR_SPACE JCS_RGB565            # 5-bit red/6-bit green/5-bit blue
+
+    cdef struct jpeg_common_struct:
+        pass
+    ctypedef jpeg_common_struct* j_common_ptr
+
+    cdef struct jpeg_source_mgr:
+        pass
+    cdef struct jpeg_decompress_struct:
+        jpeg_error_mgr *err             # Error handler module
+        jpeg_source_mgr *src
+        int input_components            # # of color components in input image
+        J_COLOR_SPACE in_color_space    # colorspace of input image
+        J_COLOR_SPACE out_color_space   # colorspace for output
+        JDIMENSION output_width         # scaled image width
+        JDIMENSION output_height        # scaled image height
+        int out_color_components        # # of color components in out_color_space
+        int output_components           # # of color components returned
+                                        # output_components is 1 (a colormap index) when quantizing colors
+                                        # otherwise it equals out_color_components.
+        JDIMENSION output_scanline      # 0 .. output_height-1
+
+
+    cdef struct jpeg_error_mgr:
+        # Error exit handler: does not return to caller
+        void (*error_exit) (j_common_ptr cinfo)
+        # Conditionally emit a trace or warning message
+        void (*emit_message) (j_common_ptr cinfo, int msg_level)
+        # Routine that actually outputs a trace or error message
+        void (*output_message) (j_common_ptr cinfo)
+        # Format a message string for the most recent JPEG error or message
+        void (*format_message) (j_common_ptr cinfo, char *buffer)
+        # Reset error state variables at start of a new image
+        void (*reset_error_mgr) (j_common_ptr cinfo)
+        # The message ID code and any parameters are saved here.
+        # A message can have one string parameter or up to 8 int parameters.
+        int msg_code
+        #msg_parm union / TODO
+        int trace_level                 # max msg_level that will be displayed
+        long num_warnings               # number of corrupt-data warnings
+
+    jpeg_error_mgr * jpeg_std_error(jpeg_error_mgr *err)
+
+    ctypedef jpeg_decompress_struct* j_decompress_ptr
+
+    ctypedef unsigned char JSAMPLE
+    ctypedef JSAMPLE *JSAMPROW          # ptr to one image row of pixel samples.
+    ctypedef JSAMPROW *JSAMPARRAY       # ptr to some rows (a 2-D sample array)
+    ctypedef JSAMPARRAY *JSAMPIMAGE
+
+    void jpeg_CreateDecompress(j_decompress_ptr cinfo, int version, size_t structsize)
+    void jpeg_mem_src(j_decompress_ptr cinfo, const unsigned char *inbuffer, unsigned long insize)
+    boolean jpeg_start_decompress(j_decompress_ptr cinfo)
+    int jpeg_read_header(j_decompress_ptr cinfo, boolean require_image)
+    JDIMENSION jpeg_read_scanlines(j_decompress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION max_lines)
+    void jpeg_finish_decompress(j_decompress_ptr cinfo)
+    void jpeg_destroy_decompress(j_decompress_ptr cinfo)
+
+
+cdef extern from "jerror.h":
+    pass
+
+cdef extern from "stdlib.h":
+    void free(void *ptr)
+
+
+cdef extern from "../../buffers/memalign.h":
+    void *xmemalign(size_t size)
+
+cdef extern from "../../buffers/buffers.h":
+    object memory_as_pybuffer(void* ptr, Py_ssize_t buf_len, int readonly)
+    int    object_as_buffer(object obj, const void ** buffer, Py_ssize_t * buffer_len)
+
+
+def get_version():
+    return JPEG_LIB_VERSION
+
+def get_encodings():
+    return ["jpeg"]
+
+
+cdef inline uint32_t roundup(uint32_t n, uint32_t m):
+    return (n + m - 1) & ~(m - 1)
+
+
+def decompress(data, int width, int height, options={}):
+    cdef const uint8_t *buf
+    cdef Py_ssize_t buf_len
+    assert object_as_buffer(data, <const void**> &buf, &buf_len)==0, "unable to convert %s to a buffer" % type(data)
+
+    cdef jpeg_decompress_struct cinfo
+    cdef jpeg_error_mgr jerr
+    cinfo.err = jpeg_std_error(&jerr)
+    jpeg_CreateDecompress(&cinfo, JPEG_LIB_VERSION, sizeof(jpeg_decompress_struct))
+
+    jpeg_mem_src(&cinfo, buf, buf_len)
+    rc = jpeg_read_header(&cinfo, True)
+    if rc!=1:
+        log.error("Error: data does not seem to be a normal JPEG")
+        return None
+    jpeg_start_decompress(&cinfo)
+    assert cinfo.output_width==width and cinfo.output_height==height, "invalid JPEG dimensions: expected %ix%i but got %ix%i" % (width, height, cinfo.output_width, cinfo.output_height)
+    log("jpeg.decoder decompress image: %ix%i", cinfo.output_width, cinfo.output_height)
+    cdef int pixel_size = cinfo.output_components
+    cdef unsigned int rowstride = pixel_size * cinfo.output_width
+    cdef size_t out_size = rowstride * cinfo.output_height
+    cdef MemBuf pixels = getbuf(out_size)
+    cdef uintptr_t rgb = <uintptr_t> pixels.get_mem()    
+
+    while cinfo.output_scanline < cinfo.output_height:
+        assert jpeg_read_scanlines(&cinfo, <JSAMPARRAY> &rgb, 1)==1
+        rgb += rowstride
+
+    jpeg_finish_decompress(&cinfo)
+    jpeg_destroy_decompress(&cinfo)
+    return ImageWrapper(0, 0, cinfo.output_width, cinfo.output_height, memoryview(pixels), "RGB", 24, rowstride, ImageWrapper.PACKED)
+
+def selftest(full=False):
+    try:
+        log("jpeg selftest")
+        import binascii
+        data = binascii.unhexlify("ffd8ffe000104a46494600010101004800480000fffe00134372656174656420776974682047494d50ffdb0043000302020302020303030304030304050805050404050a070706080c0a0c0c0b0a0b0b0d0e12100d0e110e0b0b1016101113141515150c0f171816141812141514ffdb00430103040405040509050509140d0b0d1414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414ffc20011080010001003011100021101031101ffc4001500010100000000000000000000000000000008ffc40014010100000000000000000000000000000000ffda000c03010002100310000001aa4007ffc40014100100000000000000000000000000000020ffda00080101000105021fffc40014110100000000000000000000000000000020ffda0008010301013f011fffc40014110100000000000000000000000000000020ffda0008010201013f011fffc40014100100000000000000000000000000000020ffda0008010100063f021fffc40014100100000000000000000000000000000020ffda0008010100013f211fffda000c03010002000300000010924fffc40014110100000000000000000000000000000020ffda0008010301013f101fffc40014110100000000000000000000000000000020ffda0008010201013f101fffc40014100100000000000000000000000000000020ffda0008010100013f101fffd9")
+        img = decompress(data, 16, 16)
+        log("decompress(%i bytes)=%s", len(data), img)
+    finally:
+        pass

xpra/codecs/loader.py

@@ -183 +183 @@
         codec_import_check("dec_pillow", "Pillow decoder", "xpra.codecs.pillow", "xpra.codecs.pillow.decode", "decode")
         add_codec_version("dec_pillow", "xpra.codecs.pillow.decode")
 
+        codec_import_check("dec_jpeg", "JPEG decoder", "xpra.codecs.jpeg", "xpra.codecs.jpeg.decoder", "decoder")
+        add_codec_version("dec_jpeg", "xpra.codecs.jpeg.decoder")
+
         codec_import_check("dec_vpx", "vpx decoder", "xpra.codecs.vpx", "xpra.codecs.vpx.decoder", "Decoder")
         add_codec_version("vpx", "xpra.codecs.vpx.encoder")
 
@@ -226 +229 @@
 
 CSC_CODECS = "csc_swscale", "csc_libyuv"
 ENCODER_CODECS = "enc_pillow", "enc_vpx", "enc_x264", "enc_x265", "nvenc7", "enc_ffmpeg"
-DECODER_CODECS = "dec_pillow", "dec_vpx", "dec_avcodec2"
+DECODER_CODECS = "dec_pillow", "dec_vpx", "dec_avcodec2", "dec_jpeg"
 
 ALL_CODECS = tuple(set(CSC_CODECS + ENCODER_CODECS + DECODER_CODECS))
 

xpra/log.py

@@ -208 +208 @@
                 ("libav"        , "libav common code (used by swscale, avcodec and ffmpeg)"),
                 ("ffmpeg"       , "ffmpeg encoder"),
                 ("pillow"       , "Pillow encoder and decoder"),
+                ("jpeg"         , "JPEG codec"),
                 ("vpx"          , "libvpx encoder and decoder"),
                 ("nvenc"        , "nvenc encoder (all versions)"),
                 ("x264"         , "libx264 encoder"),

setup.py

@@ -180 +180 @@
 enc_x264_ENABLED        = DEFAULT and pkg_config_ok("--exists", "x264", fallback=WIN32)
 enc_x265_ENABLED        = DEFAULT and pkg_config_ok("--exists", "x265")
 pillow_ENABLED          = DEFAULT
+jpeg_ENABLED            = DEFAULT and pkg_config_ok("--exists", "libjpeg")
 vpx_ENABLED             = DEFAULT and pkg_config_version("1.3", "vpx", fallback=WIN32)
 enc_ffmpeg_ENABLED      = DEFAULT and pkg_config_version("56", "libavcodec")
 webcam_ENABLED          = DEFAULT and not OSX
@@ -214 +215 @@
 #allow some of these flags to be modified on the command line:
 SWITCHES = ["enc_x264", "enc_x265", "enc_ffmpeg",
             "nvenc7", "cuda_rebuild",
-            "vpx", "pillow",
+            "vpx", "pillow", "jpeg",
             "v4l2",
             "dec_avcodec2", "csc_swscale",
             "csc_libyuv",
@@ -941 +942 @@
                    "xpra/codecs/cuda_common/BGRA_to_YUV444.fatbin",
                    "xpra/codecs/enc_x264/encoder.c",
                    "xpra/codecs/enc_x265/encoder.c",
+                   "xpra/codecs/jpeg/encode.c",
+                   "xpra/codecs/jpeg/decode.c",
                    "xpra/codecs/enc_ffmpeg/encoder.c",
                    "xpra/codecs/v4l2/constants.pxi",
                    "xpra/codecs/v4l2/pusher.c",
@@ -2335 +2338 @@
 if pillow_ENABLED:
     external_includes += ["PIL", "PIL.Image", "PIL.WebPImagePlugin"]
 
+toggle_packages(jpeg_ENABLED, "xpra.codecs.jpeg")
+if jpeg_ENABLED:
+    jpeg_pkgconfig = pkgconfig("libjpeg")
+    cython_add(Extension("xpra.codecs.jpeg.encoder",
+                ["xpra/codecs/jpeg/encoder.pyx", buffers_c],
+                **jpeg_pkgconfig))
+    cython_add(Extension("xpra.codecs.jpeg.decoder",
+                ["xpra/codecs/jpeg/decoder.pyx"]+membuffers_c,
+                **jpeg_pkgconfig))
+
 #swscale and avcodec2 use libav_common/av_log:
 libav_common = dec_avcodec2_ENABLED or csc_swscale_ENABLED
 toggle_packages(libav_common, "xpra.codecs.libav_common")