Ticket #486: info-namespace.patch

xpra/child_reaper.py

@@ -186 +186 @@
 
     def get_info(self):
         iv = list(self._proc_info)
-        info = {"children"          : len(iv),
-                "children.dead"     : len([x for x in iv if x.dead]),
-                "children.ignored"  : len([x for x in iv if x.ignore])}
+        info = {"children"  : {""           : len(iv),
+                               "dead"       : len([x for x in iv if x.dead]),
+                               "ignored"    : len([x for x in iv if x.ignore])}}
         pi = sorted(self._proc_info, key=lambda x: x.pid, reverse=True)
+        cinfo = {}
         for i, procinfo in enumerate(pi):
             d = dict((k,getattr(procinfo,k)) for k in ("name", "command", "ignore", "forget", "returncode", "dead", "pid"))
-            updict(info, "child[%i]" % i, d)
+            cinfo[i] = d
+        updict(info, "child", cinfo)
         return info

xpra/client/gl/gtk_compat.py

@@ -27 +27 @@
 
     def get_info():
         return {
-                "gdkgl.version"         : GdkGLExt._version,
-                "gtkgl.version"         : GtkGLExt._version,
+                "gdkgl"     : {"version"    : GdkGLExt._version},
+                "gtkgl"     : {"version"    : GtkGLExt._version},
                 }
     gdkgl = GdkGLExt
     gtkgl = GtkGLExt
@@ -74 +74 @@
         return None
 
     def get_info():
+        def v(x):
+            return {"version" : x}
         return {
-                 "pygdkglext.version"   : gdkgl.pygdkglext_version,
-                 "gtkglext.version"     : gtkgl.gtkglext_version,
-                 "gdkglext.version"     : gdkgl.gdkglext_version,
-                 "gdkgl.version"        : gdkgl.query_version()
+                 "pygdkglext"   : v(gdkgl.pygdkglext_version),
+                 "gtkglext"     : v(gtkgl.gtkglext_version),
+                 "gdkglext"     : v(gdkgl.gdkglext_version),
+                 "gdkgl"        : v(gdkgl.query_version())
                  }
 
     class GLContextManager(object):

xpra/client/ui_client_base.py

@@ -2420 +2420 @@
             ss.add_data(data, metadata)
         if self.av_sync and self.server_av_sync:
             info = ss.get_info()
-            queue_used = info.get("queue.cur")
+            queue_used = info.get("queue.cur") or info.get("queue", {}).get("cur")
             if queue_used is None:
                 return
             delta = (self.queue_used_sent or 0)-queue_used

xpra/clipboard/clipboard_base.py

@@ -23 +23 @@
 from xpra.gtk_common.gtk_util import GetClipboard, PROPERTY_CHANGE_MASK
 from xpra.gtk_common.nested_main import NestedMainLoop
 from xpra.net.compression import Uncompressed
-from xpra.util import csv
+from xpra.util import csv, updict
 
 
 MIN_CLIPBOARD_COMPRESSION_SIZE = 512
@@ -91 +91 @@
                 "want_targets"  : self._want_targets,
                 }
         for clipboard, proxy in self._clipboard_proxies.items():
-            for k,v in proxy.get_info().items():
-                info["%s.%s" % (clipboard, k)] = v
+            info[clipboard] = proxy.get_info()
         return info
 
     def cleanup(self):
@@ -463 +462 @@
                 "enabled"       : self._enabled,
                 "greedy_client" : self._greedy_client,
                 "blocked_owner_change" : self._block_owner_change,
-                "event.selection_request"   : self._selection_request_events,
-                "event.selection_get"       : self._selection_get_events,
-                "event.selection_clear"     : self._selection_clear_events,
-                "event.got_token"           : self._got_token_events,
-                "event.sent_token"          : self._sent_token_events,
-                "event.get_contents"        : self._get_contents_events,
-                "event.request_contents"    : self._request_contents_events,
                 }
+        updict(info, "event", {
+                "selection_request"     : self._selection_request_events,
+                "selection_get"         : self._selection_get_events,
+                "selection_clear"       : self._selection_clear_events,
+                "got_token"             : self._got_token_events,
+                "sent_token"            : self._sent_token_events,
+                "get_contents"          : self._get_contents_events,
+                "request_contents"      : self._request_contents_events})
         return info
 
     def cleanup(self):

xpra/codecs/enc_ffmpeg/__init__.py

@@ +1 @@
+# This file is part of Xpra.
+# Copyright (C) 2016 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/enc_ffmpeg/encoder.pyx

@@ +1 @@
+# This file is part of Xpra.
+# Copyright (C) 2012-2014 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.
+
+import weakref
+from xpra.log import Logger
+log = Logger("decoder", "ffmpeg")
+
+from xpra.codecs.codec_constants import get_subsampling_divs
+from xpra.codecs.image_wrapper import ImageWrapper
+from xpra.codecs.libav_common.av_log cimport override_logger, restore_logger #@UnresolvedImport
+from xpra.util import bytestostr
+
+
+ctypedef unsigned long size_t
+ctypedef unsigned char uint8_t
+
+
+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)
+    int get_buffer_api_version()
+
+cdef extern from "string.h":
+    void * memcpy(void * destination, void * source, size_t num) nogil
+    void * memset(void * ptr, int value, size_t num) nogil
+    void free(void * ptr) nogil
+
+
+cdef extern from "../../inline.h":
+    pass
+
+cdef extern from "../../buffers/memalign.h":
+    void *xmemalign(size_t size)
+
+
+cdef extern from "libavutil/mem.h":
+    void av_free(void *ptr)
+
+cdef extern from "libavutil/error.h":
+    int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
+
+cdef extern from "libavcodec/version.h":
+    int LIBAVCODEC_VERSION_MAJOR
+    int LIBAVCODEC_VERSION_MINOR
+    int LIBAVCODEC_VERSION_MICRO
+
+#why can't we define this inside the avcodec.h section? (beats me)
+ctypedef unsigned int AVCodecID
+ctypedef long AVPixelFormat
+
+
+cdef extern from "libavutil/pixfmt.h":
+    AVPixelFormat AV_PIX_FMT_NONE
+    AVPixelFormat AV_PIX_FMT_YUV420P
+
+cdef extern from "libavcodec/avcodec.h":
+    int CODEC_FLAG2_FAST
+
+    ctypedef struct AVFrame:
+        uint8_t **data
+        int *linesize
+        int format
+        void *opaque
+    ctypedef struct AVCodec:
+        pass
+    ctypedef struct AVDictionary:
+        pass
+    ctypedef struct AVPacket:
+        uint8_t *data
+        int      size
+
+    ctypedef struct AVCodecContext:
+        int width
+        int height
+        AVPixelFormat pix_fmt
+        int thread_safe_callbacks
+        int thread_count
+        int thread_type
+        int flags
+        int flags2
+        int refcounted_frames
+
+    AVCodecID AV_CODEC_ID_H264
+    AVCodecID AV_CODEC_ID_H265
+    AVCodecID AV_CODEC_ID_VP8
+    AVCodecID AV_CODEC_ID_VP9
+    AVCodecID AV_CODEC_ID_MPEG4
+
+    #init and free:
+    void avcodec_register_all()
+    AVCodec *avcodec_find_decoder(AVCodecID id)
+    AVCodecContext *avcodec_alloc_context3(const AVCodec *codec)
+    int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
+    AVFrame* av_frame_alloc()
+    void av_frame_free(AVFrame **frame)
+    int avcodec_close(AVCodecContext *avctx)
+
+    #actual decoding:
+    void av_init_packet(AVPacket *pkt) nogil
+    void avcodec_get_frame_defaults(AVFrame *frame) nogil
+    int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
+                                int *got_picture_ptr, const AVPacket *avpkt) nogil
+
+    void av_frame_unref(AVFrame *frame) nogil
+
+
+FORMAT_TO_ENUM = {
+            "YUV420P"   : AV_PIX_FMT_YUV420P,
+            "YUV422P"   : AV_PIX_FMT_YUV422P,
+            "YUV444P"   : AV_PIX_FMT_YUV444P,
+            "RGB"       : AV_PIX_FMT_RGB24,
+            "XRGB"      : AV_PIX_FMT_0RGB,
+            "BGRX"      : AV_PIX_FMT_BGR0,
+            "ARGB"      : AV_PIX_FMT_ARGB,
+            "BGRA"      : AV_PIX_FMT_BGRA,
+            "GBRP"      : AV_PIX_FMT_GBRP,
+            }
+
+COLORSPACES = FORMAT_TO_ENUM.keys()
+ENUM_TO_FORMAT = {}
+for pix_fmt, av_enum in FORMAT_TO_ENUM.items():
+    ENUM_TO_FORMAT[av_enum] = pix_fmt
+
+def get_version():
+    return (LIBAVCODEC_VERSION_MAJOR, LIBAVCODEC_VERSION_MINOR, LIBAVCODEC_VERSION_MICRO)
+
+avcodec_register_all()
+CODECS = []
+if avcodec_find_decoder(AV_CODEC_ID_H264)!=NULL:
+    CODECS.append("h264")
+if avcodec_find_decoder(AV_CODEC_ID_VP8)!=NULL:
+    CODECS.append("vp8")
+if avcodec_find_decoder(AV_CODEC_ID_VP9)!=NULL:
+    CODECS.append("vp9")
+if avcodec_find_decoder(AV_CODEC_ID_H265)!=NULL:
+    CODECS.append("h265")
+if avcodec_find_decoder(AV_CODEC_ID_MPEG4)!=NULL:
+    CODECS.append("mpeg4")
+log("enc_ffmpeg.init_module: CODECS=%s", CODECS)
+
+
+def init_module():
+    log("enc_ffmpeg.init_module()")
+    override_logger()
+
+def cleanup_module():
+    log("enc_ffmpeg.cleanup_module()")
+    restore_logger()
+
+def get_type():
+    return "ffmpeg"
+
+def get_info():
+    f = {}
+    for e in get_encodings():
+        f["formats.%s" % e] = get_input_colorspaces(e)
+    return  {"version"      : get_version(),
+             "encodings"    : get_encodings(),
+             "buffer_api"   : get_buffer_api_version(),
+             "formats"      : f,
+             }
+
+def get_encodings():
+    global CODECS
+    return CODECS
+
+def get_input_colorspaces(encoding):
+    return ["YUV420P"]
+
+def get_output_colorspace(encoding, csc):
+    if encoding not in CODECS:
+        return ""
+    return "YUV420P"
+
+
+cdef void clear_frame(AVFrame *frame):
+    assert frame!=NULL, "frame is not set!"
+    for i in range(4):
+        frame.data[i] = NULL
+
+
+cdef class AVFrameWrapper:
+    """
+        Wraps an AVFrame so we can free it
+        once both xpra and avcodec are done with it.
+    """
+    cdef AVCodecContext *avctx
+    cdef AVFrame *frame
+    cdef int xpra_freed
+
+    cdef set_context(self, AVCodecContext *avctx, AVFrame *frame):
+        self.avctx = avctx
+        self.frame = frame
+        log("%s.set_context(%#x, %#x)", self, <unsigned long> avctx, <unsigned long> frame)
+
+    def __dealloc__(self):
+        #By the time this wrapper is garbage collected,
+        #we must have freed it!
+        assert self.frame==NULL and self.avctx==NULL, "frame was freed by both, but not actually freed!"
+
+    def __str__(self):
+        if self.frame==NULL:
+            return "AVFrameWrapper(NULL)"
+        return "AVFrameWrapper(%#x)" % <unsigned long> self.frame
+
+    def xpra_free(self):
+        log("%s.xpra_free()", self)
+        self.free()
+
+    cdef free(self):
+        log("%s.free() context=%#x, frame=%#x", self, <unsigned long> self.avctx, <unsigned long> self.frame)
+        if self.avctx!=NULL and self.frame!=NULL:
+            av_frame_unref(self.frame)
+            self.frame = NULL
+            self.avctx = NULL
+
+
+class AVImageWrapper(ImageWrapper):
+    """
+        Wrapper which allows us to call xpra_free on the decoder
+        when the image is freed, or once we have made a copy of the pixels.
+    """
+
+    def __repr__(self):                          #@DuplicatedSignature
+        return ImageWrapper.__repr__(self)+"-(%s)" % self.av_frame
+
+    def free(self):                             #@DuplicatedSignature
+        log("AVImageWrapper.free()")
+        ImageWrapper.free(self)
+        self.xpra_free_frame()
+
+    def clone_pixel_data(self):
+        log("AVImageWrapper.clone_pixel_data()")
+        ImageWrapper.clone_pixel_data(self)
+        self.xpra_free_frame()
+
+    def xpra_free_frame(self):
+        av_frame = self.av_frame
+        log("AVImageWrapper.xpra_free_frame() av_frame=%s", av_frame)
+        if av_frame:
+            self.av_frame = None
+            av_frame.xpra_free()
+
+
+cdef class Encoder:
+    """
+        This wraps the AVCodecContext and its configuration,
+        also tracks AVFrames.
+        It also handles reconstructing a single ImageWrapper
+        constructed from 3-pass decoding (see plane_sizes).
+    """
+    cdef AVCodec *codec
+    cdef AVCodecContext *codec_ctx
+    cdef AVPixelFormat pix_fmt
+    cdef AVPixelFormat actual_pix_fmt
+    cdef object colorspace
+    cdef object weakref_images
+    cdef AVFrame *av_frame
+    #this is the actual number of images we have returned
+    cdef unsigned long frames
+    cdef int width
+    cdef int height
+    cdef object encoding
+
+    cdef object __weakref__
+
+    def init_context(self, encoding, int width, int height, colorspace):
+        cdef int r
+        cdef int i
+        assert encoding in CODECS
+        self.encoding = encoding
+        self.width = width
+        self.height = height
+        assert colorspace in COLORSPACES, "invalid colorspace: %s" % colorspace
+        self.colorspace = ""
+        for x in COLORSPACES:
+            if x==colorspace:
+                self.colorspace = x
+                break
+        if not self.colorspace:
+            log.error("invalid pixel format: %s", colorspace)
+            return  False
+        self.pix_fmt = FORMAT_TO_ENUM.get(colorspace, AV_PIX_FMT_NONE)
+        if self.pix_fmt==AV_PIX_FMT_NONE:
+            log.error("invalid pixel format: %s", colorspace)
+            return  False
+        self.actual_pix_fmt = self.pix_fmt
+
+        avcodec_register_all()
+
+        cdef AVCodecID CodecID
+        if self.encoding=="h264":
+            CodecID = AV_CODEC_ID_H264
+        elif self.encoding=="h265":
+            CodecID = AV_CODEC_ID_H265
+        elif self.encoding=="vp8":
+            CodecID = AV_CODEC_ID_VP8
+        elif self.encoding=="vp9":
+            CodecID = AV_CODEC_ID_VP9
+        elif self.encoding=="mpeg4":
+            CodecID = AV_CODEC_ID_MPEG4
+        else:
+            raise Exception("invalid codec; %s" % self.encoding)
+        self.codec = avcodec_find_decoder(CodecID)
+        if self.codec==NULL:
+            log.error("codec %s not found!" % self.encoding)
+            return  False
+
+        #from here on, we have to call clean_decoder():
+        self.codec_ctx = avcodec_alloc_context3(self.codec)
+        if self.codec_ctx==NULL:
+            log.error("failed to allocate codec context!")
+            self.clean_decoder()
+            return  False
+
+        self.codec_ctx.refcounted_frames = 1
+        self.codec_ctx.width = width
+        self.codec_ctx.height = height
+        self.codec_ctx.pix_fmt = self.pix_fmt
+        #self.codec_ctx.get_buffer2 = avcodec_get_buffer2
+        #self.codec_ctx.release_buffer = avcodec_release_buffer
+        self.codec_ctx.thread_safe_callbacks = 1
+        self.codec_ctx.thread_type = 2      #FF_THREAD_SLICE: allow more than one thread per frame
+        self.codec_ctx.thread_count = 0     #auto
+        self.codec_ctx.flags2 |= CODEC_FLAG2_FAST   #may cause "no deblock across slices" - which should be fine
+        r = avcodec_open2(self.codec_ctx, self.codec, NULL)
+        if r<0:
+            log.error("could not open codec: %s", self.av_error_str(r))
+            self.clean_decoder()
+            return  False
+        #up to 3 AVFrame objects used:
+        self.av_frame = av_frame_alloc()
+        if self.av_frame==NULL:
+            log.error("could not allocate an AVFrame for decoding")
+            self.clean_decoder()
+            return  False
+        self.frames = 0
+        #to keep track of images not freed yet:
+        #(we want a weakref.WeakSet() but this is python2.7+ only..)
+        self.weakref_images = []
+        #register this decoder in the global dictionary:
+        log("dec_avcodec.Decoder.init_context(%s, %s, %s) self=%s", width, height, colorspace, self.get_info())
+        return True
+
+    def clean(self):
+        self.clean_decoder()
+        self.codec = NULL
+        self.pix_fmt = 0
+        self.actual_pix_fmt = 0
+        self.colorspace = ""
+        self.weakref_images = []
+        self.av_frame = NULL                        #should be redundant
+        self.frames = 0
+        self.width = 0
+        self.height = 0
+        self.encoding = ""
+
+
+    def clean_decoder(self):
+        cdef int r, i
+        log("%s.clean_decoder()", self)
+        #we may have images handed out, ensure we don't reference any memory
+        #that needs to be freed using avcodec_release_buffer(..)
+        #as this requires the context to still be valid!
+        #copying the pixels should ensure we free the AVFrameWrapper associated with it:
+        if self.weakref_images:
+            images = [y for y in [x() for x in self.weakref_images] if y is not None]
+            self.weakref_images = []
+            log("clean_decoder() cloning pixels for images still in use: %s", images)
+            for img in images:
+                if not img.freed:
+                    img.clone_pixel_data()
+
+        if self.av_frame!=NULL:
+            log("clean_decoder() freeing AVFrame: %#x", <unsigned long> self.av_frame)
+            av_frame_free(&self.av_frame)
+            #redundant: self.frame = NULL
+
+        cdef unsigned long ctx_key          #@DuplicatedSignature
+        log("clean_decoder() freeing AVCodecContext: %#x", <unsigned long> self.codec_ctx)
+        if self.codec_ctx!=NULL:
+            r = avcodec_close(self.codec_ctx)
+            if r!=0:
+                log.warn("error closing decoder context %#x: %s", <unsigned long> self.codec_ctx, self.av_error_str(r))
+            av_free(self.codec_ctx)
+            self.codec_ctx = NULL
+        log("clean_decoder() done")
+
+    cdef av_error_str(self, errnum):
+        cdef char[128] err_str
+        cdef int i = 0
+        if av_strerror(errnum, err_str, 128)==0:
+            while i<128 and err_str[i]!=0:
+                i += 1
+            return bytestostr(err_str[:i])
+        return str(errnum)
+
+    def __repr__(self):                      #@DuplicatedSignature
+        if self.is_closed():
+            return "dec_avcodec.Decoder(*closed*)"
+        return "dec_avcodec.Decoder(%s)" % self.get_info()
+
+    def get_info(self):                      #@DuplicatedSignature
+        info = {"version"   : get_version(),
+                "encoding"  : self.encoding,
+                "formats"   : get_input_colorspaces(self.encoding),
+                "type"      : self.get_type(),
+                "frames"    : self.frames,
+                "width"     : self.width,
+                "height"    : self.height,
+                }
+        if self.colorspace:
+            info["colorspace"] = self.colorspace
+            info["actual_colorspace"] = self.get_actual_colorspace()
+        if not self.is_closed():
+            info["decoder_width"] = self.codec_ctx.width
+            info["decoder_height"] = self.codec_ctx.height
+        else:
+            info["closed"] = True
+        return info
+
+    def is_closed(self):
+        return self.codec_ctx==NULL
+
+    def __dealloc__(self):                          #@DuplicatedSignature
+        self.clean()
+
+    def get_width(self):
+        return self.width
+
+    def get_height(self):
+        return self.height
+
+    def get_encoding(self):
+        return self.encoding
+
+    def get_type(self):                             #@DuplicatedSignature
+        return "avcodec"
+
+    def decompress_image(self, input, options):
+        cdef unsigned char * padded_buf = NULL
+        cdef const unsigned char * buf = NULL
+        cdef Py_ssize_t buf_len = 0
+        cdef int size
+        cdef int len = 0
+        cdef int nplanes
+        cdef int got_picture
+        cdef AVPacket avpkt
+        cdef unsigned long frame_key                #@DuplicatedSignature
+        cdef AVFrameWrapper framewrapper
+        cdef AVFrame *av_frame
+        cdef object img
+        assert self.codec_ctx!=NULL, "no codec context! (not initialized or already closed)"
+        assert self.codec!=NULL
+
+        #copy the whole input buffer into a padded C buffer:
+        assert object_as_buffer(input, <const void**> &buf, &buf_len)==0
+        padded_buf = <unsigned char *> xmemalign(buf_len+128)
+        memcpy(padded_buf, buf, buf_len)
+        memset(padded_buf+buf_len, 0, 128)
+
+        #note: plain RGB output, will redefine those:
+        out = []
+        strides = []
+        outsize = 0
+
+        #ensure we can detect if the frame buffer got allocated:
+        clear_frame(self.av_frame)
+        #now safe to run without gil:
+        with nogil:
+            av_init_packet(&avpkt)
+            avpkt.data = <uint8_t *> (padded_buf)
+            avpkt.size = buf_len
+            len = avcodec_decode_video2(self.codec_ctx, self.av_frame, &got_picture, &avpkt)
+        if len<0:
+            av_frame_unref(self.av_frame)
+            log("%s.decompress_image(%s:%s, %s) avcodec_decode_video2 failure: %s", self, type(input), buf_len, options, self.av_error_str(len))
+            log.error("avcodec_decode_video2 %s decoding failure:", self.encoding)
+            log.error(" %s", self.av_error_str(len))
+            return None
+        if len==0:
+            av_frame_unref(self.av_frame)
+            log("%s.decompress_image(%s:%s, %s) avcodec_decode_video2 failed to decode the stream", self, type(input), buf_len, options)
+            log.error("avcodec_decode_video2 %s decoding failure - no stream", self.encoding)
+            return None
+
+        if self.actual_pix_fmt!=self.av_frame.format:
+            if self.av_frame.format==-1:
+                log.error("avcodec error decoding %i bytes of %s data", buf_len, self.encoding)
+                log.error(" frame %i", self.frames)
+                log.error(" options=%s", options)
+                log.error(" decoder state:")
+                for k,v in self.get_info().items():
+                    log.error("  %s = %s", k, v)
+                return None
+            self.actual_pix_fmt = self.av_frame.format
+            if self.actual_pix_fmt not in ENUM_TO_FORMAT:
+                av_frame_unref(self.av_frame)
+                log.error("unknown output pixel format: %s, expected %s (%s)", self.actual_pix_fmt, self.pix_fmt, self.colorspace)
+                return None
+            log("avcodec actual output pixel format is %s (%s), expected %s (%s)", self.actual_pix_fmt, self.get_actual_colorspace(), self.pix_fmt, self.colorspace)
+
+        cs = self.get_actual_colorspace()
+        if cs.endswith("P"):
+            divs = get_subsampling_divs(cs)
+            nplanes = 3
+            for i in range(3):
+                _, dy = divs[i]
+                if dy==1:
+                    height = self.codec_ctx.height
+                elif dy==2:
+                    height = (self.codec_ctx.height+1)>>1
+                else:
+                    av_frame_unref(self.av_frame)
+                    raise Exception("invalid height divisor %s" % dy)
+                stride = self.av_frame.linesize[i]
+                size = height * stride
+                outsize += size
+
+                out.append(memory_as_pybuffer(<void *>self.av_frame.data[i], size, True))
+                strides.append(stride)
+                log("decompress_image() read back yuv plane %s: %s bytes", i, size)
+        else:
+            #RGB mode: "out" is a single buffer
+            strides = self.av_frame.linesize[0]+self.av_frame.linesize[1]+self.av_frame.linesize[2]
+            outsize = self.codec_ctx.height * strides
+            out = memory_as_pybuffer(<void *>self.av_frame.data[0], outsize, True)
+            nplanes = 0
+            log("decompress_image() read back rgb buffer: %s bytes", outsize)
+
+        #FIXME: we could lose track of framewrappers if an error occurs before the end:
+        framewrapper = AVFrameWrapper()
+        framewrapper.set_context(self.codec_ctx, self.av_frame)
+
+        if outsize==0:
+            av_frame_unref(self.av_frame)
+            raise Exception("output size is zero!")
+
+        free(padded_buf)
+        assert self.codec_ctx.width>=self.width, "codec width is smaller than our width: %s<%s" % (self.codec_ctx.width, self.width)
+        assert self.codec_ctx.height>=self.height, "codec height is smaller than our height: %s<%s" % (self.codec_ctx.height, self.height)
+        img = AVImageWrapper(0, 0, self.width, self.height, out, cs, 24, strides, nplanes, thread_safe=False)
+        img.av_frame = framewrapper
+        self.frames += 1
+        #add to weakref list after cleaning it up:
+        self.weakref_images = [x for x in self.weakref_images if x() is not None]
+        self.weakref_images.append(weakref.ref(img))
+        log("%s.decompress_image(%s:%s, %s)=%s", self, type(input), buf_len, options, img)
+        return img
+
+
+    def get_colorspace(self):
+        return self.colorspace
+
+    def get_actual_colorspace(self):
+        return ENUM_TO_FORMAT.get(self.actual_pix_fmt, "unknown/invalid")
+
+
+def selftest(full=False):
+    global CODECS
+    from xpra.codecs.codec_checks import testdecoder
+    from xpra.codecs.dec_avcodec2 import decoder
+    global CODECS
+    CODECS = testdecoder(decoder, full)

xpra/codecs/mkv/__init__.py

@@ +1 @@
+# This file is part of Xpra.
+# Copyright (C) 2016 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/mkv/muxer.pyx

@@ +1 @@
+# This file is part of Xpra.
+# Copyright (C) 2016 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.
+
+import time
+import os
+
+from xpra.log import Logger
+log = Logger("encoder", "mkv")
+
+from libc.stdint cimport int64_t
+
+cdef extern from "string.h":
+    void *memset(void *ptr, int value, size_t num) nogil
+    void free(void *ptr) nogil
+
+cdef extern from "../../buffers/memalign.h":
+    void *xmemalign(size_t size)
+
+cdef extern from "../../buffers/buffers.h":
+    int object_as_buffer(object obj, const void ** buffer, Py_ssize_t * buffer_len)
+    int get_buffer_api_version()
+
+
+cdef extern from "libmkv.h":
+    pass
+
+cdef class Muxer:
+    cdef object __weakref__
+
+#init_context(w, h, src_format, encoding, quality, speed, scaling, options)
+    def init_context(self, int width, int height, src_format, dst_formats, encoding, int quality, int speed, scaling, options):    #@DuplicatedSignature
+        pass

xpra/codecs/nvenc4/encoder.pyx

@@ -1586 +1586 @@
                 "encoder_height"    : self.encoder_height,
                 "bitrate"           : self.target_bitrate,
                 "quality"           : self.quality,
-                "speed"             : self.speed,
-                "lossless"          : self.lossless,
-                "lossless.supported": LOSSLESS_ENABLED,
-                "lossless.threshold": LOSSLESS_THRESHOLD,
-                "yuv444.supported"  : YUV444_ENABLED,
-                "yuv444.threshold"  : YUV444_THRESHOLD,
+                "speed"             : self.speed})
+        updict(info, "lossless", {
+                ""          : self.lossless,
+                "supported" : LOSSLESS_ENABLED,
+                "threshold" : LOSSLESS_THRESHOLD})
+        updict(info, "yuv444", {
+                "supported" : YUV444_ENABLED,
+                "threshold" : YUV444_THRESHOLD,
                 })
         if self.scaling!=(1,1):
             info.update({

xpra/codecs/nvenc5/encoder.pyx

@@ -1625 +1625 @@
                 "bitrate"           : self.target_bitrate,
                 "quality"           : self.quality,
                 "speed"             : self.speed,
-                "lossless"          : self.lossless,
-                "lossless.supported": LOSSLESS_ENABLED,
-                "lossless.threshold": LOSSLESS_THRESHOLD,
-                "yuv444.supported"  : YUV444_ENABLED,
-                "yuv444.threshold"  : YUV444_THRESHOLD,
                 })
+        updict(info, "lossless", {
+                ""          : self.lossless,
+                "supported" : LOSSLESS_ENABLED,
+                "threshold" : LOSSLESS_THRESHOLD})
+        updict(info, "yuv444", {
+                "supported" : YUV444_ENABLED,
+                "threshold" : YUV444_THRESHOLD,
+                })
         if self.scaling!=(1,1):
             info.update({
                 "input_width"       : self.input_width,

xpra/codecs/nvenc6/encoder.pyx

@@ -1696 +1696 @@
                 "bitrate"           : self.target_bitrate,
                 "quality"           : self.quality,
                 "speed"             : self.speed,
-                "lossless"          : self.lossless,
-                "lossless.supported": LOSSLESS_ENABLED,
-                "lossless.threshold": LOSSLESS_THRESHOLD,
-                "yuv444.supported"  : YUV444_ENABLED,
-                "yuv444.threshold"  : YUV444_THRESHOLD,
                 })
+        updict(info, "lossless", {
+                ""          : self.lossless,
+                "supported" : LOSSLESS_ENABLED,
+                "threshold" : LOSSLESS_THRESHOLD})
+        updict(info, "yuv444", {
+                "supported" : YUV444_ENABLED,
+                "threshold" : YUV444_THRESHOLD,
+                })
         if self.scaling!=(1,1):
             info.update({
                 "input_width"       : self.input_width,

xpra/codecs/ogg/__init__.py

@@ +1 @@
+# This file is part of Xpra.
+# Copyright (C) 2016 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/ogg/muxer.pyx

@@ +1 @@
+# This file is part of Xpra.
+# Copyright (C) 2016 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.
+
+import time
+import os
+
+from xpra.log import Logger
+log = Logger("encoder", "mkv")
+
+from libc.stdint cimport int64_t
+
+cdef extern from "string.h":
+    void *memset(void *ptr, int value, size_t num) nogil
+    void free(void *ptr) nogil
+
+cdef extern from "../../buffers/memalign.h":
+    void *xmemalign(size_t size)
+
+cdef extern from "../../buffers/buffers.h":
+    int object_as_buffer(object obj, const void ** buffer, Py_ssize_t * buffer_len)
+    int get_buffer_api_version()
+
+
+cdef extern from "ogg/ogg.h":
+    pass
+
+cdef class Muxer:
+    cdef object __weakref__
+
+#init_context(w, h, src_format, encoding, quality, speed, scaling, options)
+    def init_context(self, int width, int height, src_format, dst_formats, encoding, int quality, int speed, scaling, options):    #@DuplicatedSignature
+        pass

xpra/net/bytestreams.py

@@ -215 +215 @@
         d = Connection.get_info(self)
         try:
             d["type"] = "pipe"
-            d["pipe.read.fd"] = self._read_fd
-            d["pipe.write.fd"] = self._write_fd
+            d["pipe"] = {"read"     : {"fd" : self._read_fd},
+                         "write"    : {"fd" : self._write_fd}}
         except:
             pass
         return d

xpra/net/protocol.py

@@ -210 +210 @@
 
     def get_info(self, alias_info=True):
         info = {
-            "input.packetcount"     : self.input_packetcount,
-            "input.raw_packetcount" : self.input_raw_packetcount,
-            "input.cipher"          : self.cipher_in_name or "",
-            "input.cipher.padding"  : self.cipher_in_padding,
-            "output.packetcount"    : self.output_packetcount,
-            "output.raw_packetcount": self.output_raw_packetcount,
-            "output.cipher"         : self.cipher_out_name or "",
-            "output.cipher.padding" : self.cipher_out_padding,
             "large_packets"         : self.large_packets,
             "compression_level"     : self.compression_level,
             "max_packet_size"       : self.max_packet_size}
-        updict(info, "input.count", self.input_stats)
-        updict(info, "output.count", self.output_stats)
+        updict(info, "input", {
+            "packetcount"           : self.input_packetcount,
+            "raw_packetcount"       : self.input_raw_packetcount,
+            "count"                 : self.input_stats,
+            "cipher"                : {"": self.cipher_in_name or "",
+                                       "padding"        : self.cipher_in_padding},
+             })
+        updict(info, "output", {
+            "packetcount"           : self.output_packetcount,
+            "raw_packetcount"       : self.output_raw_packetcount,
+            "count"                 : self.output_stats,
+            "cipher"                : {"": self.cipher_out_name or "",
+                                       "padding" : self.cipher_out_padding},
+            })
         c = self._compress
         if c:
             info["compressor"] = compression.get_compressor_name(self._compress)
@@ -233 +237 @@
             else:
                 info["encoder"] = packet_encoding.get_encoder_name(self._encoder)
         if alias_info:
-            for k,v in self.send_aliases.items():
-                info["send_alias." + str(k)] = v
-                info["send_alias." + str(v)] = k
-            for k,v in self.receive_aliases.items():
-                info["receive_alias." + str(k)] = v
-                info["receive_alias." + str(v)] = k
+            info["send_alias"] = self.send_aliases
+            info["receive_alias"] = self.receive_aliases
         c = self._conn
         if c:
             try:
@@ -248 +248 @@
         info["has_more"] = self._source_has_more.is_set()
         for t in (self._write_thread, self._read_thread, self._read_parser_thread, self._write_format_thread):
             if t:
-                info["thread.%s" % t.name] = t.is_alive()
+                info.setdefault("thread", {})[t.name] = t.is_alive()
         return info
 
 

xpra/net/pycrypto_backend.py

@@ -20 +20 @@
     pass
 
 def get_info():
-    caps = {"backend"           : "pycrypto",
-            "pycrypto"          : "True",
-            "pycrypto.version"  : Crypto.__version__}
     try:
         from Crypto.PublicKey import _fastmath
     except:
         _fastmath = None
-    caps["pycrypto.fastmath"] = _fastmath is not None
-    return caps
+    return {"backend"           : "pycrypto",
+            "pycrypto"          : {""           : True,
+                                   "version"    : Crypto.__version__},
+                                   "fastmath"   : _fastmath is not None}
 
 
 def get_key(password, key_salt, block_size, iterations):

xpra/net/pycryptography_backend.py

@@ -65 +65 @@
     import cryptography
     return {"backend"                       : "python-cryptography",
             "backends"                      : [ci(x) for x in getattr(backend, "_backends", [])],
-            "python-cryptography"           : True,
-            "python-cryptography.version"   : cryptography.__version__}
+            "python-cryptography"           : {""           : True,
+                                               "version"    : cryptography.__version__}
+            }
 
 def get_key(password, key_salt, block_size, iterations):
     global backend

xpra/platform/darwin/shadow_server.py

@@ -113 +113 @@
 
     def get_info(self, proto):
         info = GTKServerBase.get_info(self, proto)
-        info["features.shadow"] = True
-        info["server.type"] = "Python/gtk2/osx-shadow"
+        info.setdefault("features", {})["shadow"] = True
+        info.setdefault("server", {})["type"] = "Python/gtk2/osx-shadow"
         return info

xpra/platform/gui.py

@@ -161 +161 @@
             "desktops"                      : get_number_of_desktops(),
             "desktop_names"                 : get_desktop_names(),
             "vertical-refresh"              : get_vrefresh(),
-            "double_click.time"             : get_double_click_time(),
-            "double_click.distance"         : get_double_click_distance(),
             "fixed_cursor_size"             : get_fixed_cursor_size(),
             "cursor_size"                   : get_cursor_size(),
-            "dpi.x"                         : get_xdpi(),
-            "dpi.y"                         : get_ydpi(),
             "icon_size"                     : get_icon_size(),
             }
     from xpra.util import updict
+    updict("double_click", {
+                            "time"          : get_double_click_time(),
+                            "distance"      : get_double_click_distance(),
+                            })
+    updict("dpi", {
+                   "x"                      : get_xdpi(),
+                   "y"                      : get_ydpi()
+                   })
     updict(info, "antialias", get_antialias_info())
     updict(info, "window_frame", get_window_frame_sizes())
     return info

xpra/platform/paths.py

@@ -206 +206 @@
 
 def get_info():
     return {
-            "install.prefix"    : get_install_prefix(),
-            "default_conf.dirs" : get_default_conf_dirs(),
-            "system_conf.dirs"  : get_system_conf_dirs(),
-            "user_conf.dirs"    : get_user_conf_dirs(),
-            "socket.dirs"       : get_socket_dirs(),
-            "log.dir"           : get_default_log_dir(),
-            "download.dir"      : get_download_dir(),
-            "app.dir"           : get_app_dir(),
-            "app.default.dir"   : default_get_app_dir(),
+            "install"           : {"prefix" : get_install_prefix()},
+            "default_conf"      : {"dirs"   : get_default_conf_dirs()},
+            "system_conf"       : {"dirs"   : get_system_conf_dirs()},
+            "user_conf"         : {"dirs"   : get_user_conf_dirs()},
+            "socket"            : {"dirs"   : get_socket_dirs()},
+            "log"               : {"dir"    : get_default_log_dir()},
+            "download"          : {"dir"    : get_download_dir()},
+            "app"               : {"dir"    : get_app_dir()},
+            "app"               : {"default" : {"dir"   : default_get_app_dir()}},
             "resources"         : get_resources_dir(),
             "icons"             : get_icon_dir(),
             "home"              : os.path.expanduser("~"),

xpra/platform/printing.py

@@ -68 +68 @@
 
 
 def get_info():
-    return {
-            "mimetypes"         : get_mimetypes(),
-            "mimetypes.default" : DEFAULT_MIMETYPES,
+    return {"mimetypes" :   {""         : get_mimetypes(),
+                             "default"  : DEFAULT_MIMETYPES}
             }
 
 

xpra/platform/pycups_printing.py

@@ -416 +416 @@
 
 def get_info():
     from xpra.platform.printing import get_mimetypes, DEFAULT_MIMETYPES
-    return {
-            "mimetypes"         : get_mimetypes(),
-            "mimetypes.default" : DEFAULT_MIMETYPES,
+    return {"mimetypes"         : {""           : get_mimetypes(),
+                                   "default"    : DEFAULT_MIMETYPES,
+                                   "printers"   : MIMETYPE_TO_PRINTER,
+                                   "ppd"        : MIMETYPE_TO_PPD},
+            "mimetype"          : {"default"    : DEFAULT_MIMETYPE},
             "simulate-failure"  : SIMULATE_PRINT_FAILURE,
             "allow-user"        : ALLOW,
             "raw-mode"          : RAW_MODE,
             "generic"           : GENERIC,
             "tmpdir"            : FORWARDER_TMPDIR,
-            "mimetype.default"  : DEFAULT_MIMETYPE,
             "lpadmin"           : LPADMIN,
             "lpinfo"            : LPINFO,
             "forwarder"         : FORWARDER_BACKEND,
@@ -431 +432 @@
             "skipped-printers"  : SKIPPED_PRINTERS,
             "add-local-printers": ADD_LOCAL_PRINTERS,
             "printer-prefix"    : PRINTER_PREFIX,
-            "cups-dbus.default" : DEFAULT_CUPS_DBUS,
-            "cups-dbus"         : CUPS_DBUS,
-            "cups-dbus.poll-delay" : POLLING_DELAY,
-            "mimetypes.printers": MIMETYPE_TO_PRINTER,
-            "mimetypes.ppd"     : MIMETYPE_TO_PPD,
+            "cups-dbus"         : {""           : CUPS_DBUS,
+                                   "default"    : DEFAULT_CUPS_DBUS,
+                                   "poll-delay" : POLLING_DELAY},
             "cups.default-options"  : DEFAULT_CUPS_OPTIONS,
-            "printers.predefined" : UNPROBED_PRINTER_DEFS,
-            "printers"          : get_printer_definitions(),
+            "printers"          : {""           : get_printer_definitions(),
+                                   "predefined" : UNPROBED_PRINTER_DEFS},
             }
 
 

xpra/platform/win32/keyboard_config.py

@@ -36 +36 @@
     def __repr__(self):
         return "win32.KeyboardConfig"
 
-    def get_info(self):
-        info = KeyboardConfigBase.get_info(self)
-        return info
 
-
     def parse_options(self, props):
         return KeyboardConfigBase.parse_options(self, props)
 
@@ -122 +118 @@
     #no useful mapping:
     "ICO_CLEAR"             : "IcoClr",
     "ICO_HELP"              : "Help",
+    "DIVIDE"                : "KP_Divide",
     "MULTIPLY"              : "KP_Multiply",
+    "SUBTRACT"              : "KP_Substract",
+    "ADD"                   : "KP_Add",
     "NONAME"                : "NoSymbol",
     "NUMPAD0"               : "KP_0",
     "NUMPAD1"               : "KP_1",
@@ -167 +166 @@
     "OEM_PA1"               : "OemPa1",
     "OEM_PA2"               : "OemPa2",
     "OEM_PA3"               : "OemPa3",
-    "OEM_PLUS"              : "plus",
+    #"OEM_PLUS"              : "equal",
     "OEM_RESET"             : "Reset",
     "OEM_WSCTRL"            : "WsCtrl",
     "PA1"                   : "Pa1",
+    "OEM_102"               : "backslash",
     #missing:?
     #"PACKET"                : "Packet",
     "PLAY"                  : "Play",
@@ -263 +263 @@
     "VOLUME_UP"             : "XF86AudioRaiseVolume",
     "XBUTTON1"              : "X1",
     "XBUTTON2"              : "X2",
+    "BRACKET_LEFT"          : "bracketleft",
+    "BRACKET_RIGHT"         : "bracketright",
+    "BRACE_LEFT"            : "braceleft",
+    "BRACE_RIGHT"           : "braceright",
+    "COLON"                 : "colon",
+    "SEMICOLON"             : "semicolon",
+    "APOSTROPHE"            : "apostrophe",
+    "AT"                    : "at",
+    "NUMBER_SIGN"           : "numbersign",
+    "COMMA"                 : "comma",
+    "LESS"                  : "less",
+    "EQUAL"                 : "equal",
+    "GREATER"               : "greater",
+    "PERIOD"                : "period",
+    "SLASH"                 : "slash",
+    "QUESTION"              : "question",
+    "BAR"                   : "bar",
+    "EXCLAM"                : "exclam",
+    "QUOTEDBL"              : "quotedbl",
+    "STERLING"              : "sterling",
+    "DOLLAR"                : "dollar",
+    "PERCENT"               : "percent",
+    "ASCIICIRCUM"           : "asciicircum",
+    "AMPERSAND"             : "ampersand",
+    "ASTERISK"              : "asterisk",
+    "PARENLEFT"             : "parenleft",
+    "PARENRIGHT"            : "parenright",
+    "UNDERSCORE"            : "underscore",
+    "BACKSLASH"             : "backslash",
+    "GRAVE"                 : "grave",
 }
 
 #these aren't defined in win32con...
 DEFS = {
+    "EXCLAM"                : 33,
+    "QUOTEDBL"              : 34,
+    "NUMBER_SIGN"           : 35,
+    "DOLLAR"                : 36,
+    "PERCENT"               : 37,
+    "AMPERSAND"             : 38,
+    "APOSTROPHE"            : 39,
+    "PARENLEFT"             : 40,
+    "PARENRIGHT"            : 41,
+    "ASTERISK"              : 42,
+    "COMMA"                 : 44,
+    "PERIOD"                : 46,
+    "SLASH"                 : 47,
+    "COLON"                 : 58,
+    "SEMICOLON"             : 59,
+    "LESS"                  : 60,
+    "EQUAL"                 : 61,
+    "GREATER"               : 62,
+    "QUESTION"              : 63,
+    "AT"                    : 64,
+    "BRACKET_LEFT"          : 91,
+    "BACKSLASH"             : 92,
+    "BRACKET_RIGHT"         : 93,
+    "ASCIICIRCUM"           : 94,
+    "UNDERSCORE"            : 95,
+    "GRAVE"                 : 96,
+    "BRACE_LEFT"            : 123,
+    "BAR"                   : 124,
+    "BRACE_RIGHT"           : 125,
+    "ASCIITILDE"            : 126,
+    "STERLING"              : 156,
     "SLEEP"                 : 0x5F,
     "OEM_FJ_JISHO"          : 0x92,
     "OEM_FJ_MASSHOU"        : 0x93,
@@ -313 +374 @@
     "OEM_FINISH"            : 0xF1,
     "OEM_ENLW"              : 0xF4,
     "OEM_BACKTAB"           : 0xF5,
-    "ASCIITILDE"            : 65107,        #aka 0x00fe53
+    "ASCIITILDE"            : 126,
+    #"ASCIITILDE"            : 65107,        #aka 0x00fe53
     "DEAD_GRAVE"            : 65104,        #aka 0x00fe50
 }
 

xpra/platform/win32/shadow_server.py

@@ -393 +393 @@
 
     def get_info(self, proto):
         info = GTKServerBase.get_info(self, proto)
-        info["features.shadow"] = True
-        info["server.type"] = "Python/gtk2/win32-shadow"
-        info["server.tray"] = self.tray
-        info["server.tray-icon"] = self.tray_icon or ""
+        info.setdefault("features", {})["shadow"] = True
+        info.setdefault("server", {
+                                   "type"       : "Python/gtk2/win32-shadow",
+                                   "tray"       : self.tray,
+                                   "tray-icon"  :self.tray_icon or ""})
         return info
 
 

xpra/platform/xposix/gui.py

@@ -15 +15 @@
 traylog = Logger("posix", "menu")
 menulog = Logger("posix", "menu")
 
-from xpra.util import iround
+from xpra.util import iround, updict
 from xpra.gtk_common.gobject_compat import get_xid, is_gtk3
 
 device_bell = None
@@ -456 +456 @@
     s = _get_xsettings()
     if s:
         serial, values = s
-        i["xsettings.serial"] = serial
+        xi = {"serial"  : serial}
         for _,name,value,_ in values:
-            i["xsettings.%s" % name] = value
-    i["dpi.xsettings"] = _get_xsettings_dpi()
-    i["dpi.randr"] = _get_randr_dpi()
+            xi[name] = value
+        updict(i, "xsettings", xi)
+    i.setdefault("dpi", {
+                         "xsettings"    : _get_xsettings_dpi(),
+                         "randr"        : _get_randr_dpi()})
     return i
 
 

xpra/server/gtk_server_base.py

@@ -88 +88 @@
 
     def do_get_info(self, proto, *args):
         info = ServerBase.do_get_info(self, proto, *args)
-        updict(info, "server", get_gtk_version_info())
-        info.update({
-                     "server.type"      : "Python/gtk-x11",
-                     "features.randr"   : self.randr})
+        vi = get_gtk_version_info()
+        vi["type"] = "Python/gtk-x11"
+        info.setdefault("server", {}).update(vi)
+        info.setdefault("features", {})["randr"] = self.randr
         return info
 
     def get_root_window_size(self):

xpra/server/proxy/proxy_server.py

@@ -257 +257 @@
                 i = 0
                 for p,v in self.processes.items():
                     d,_ = v
-                    info["proxy[%s].display" % i] = d
-                    info["proxy[%s].live" % i] = p.is_alive()
-                    info["proxy[%s].pid" % i] = p.pid
+                    info[i] = {"display"    : d,
+                               "live"       : p.is_alive(),
+                               "pid"        : p.pid}
                     i += 1
                 info["proxies"] = len(self.processes)
         return info

xpra/server/server_base.py

@@ -1772 +1772 @@
                              "y"            : self.ydpi
                              })
         updict(info, "antialias", self.antialias)
-        info["cursor.size"] = self.cursor_size
+        info["cursor"] = {"size" : self.cursor_size}
         log("get_info took %.1fms", 1000.0*(time.time()-start))
         return info
 
@@ -1835 +1835 @@
              "repeat.interval"  : self.key_repeat_interval,
              "keys_pressed"     : self.keys_pressed.values(),
              "modifiers"        : self.xkbmap_mod_meanings}
-        if self.keyboard_config:
-            for k,v in self.keyboard_config.get_info().items():
-                if v is not None:
-                    info[k] = v
+        kc = self.keyboard_config
+        if kc:
+            info.update(kc.get_info())
         return info
 
     def get_clipboard_info(self):
@@ -1851 +1850 @@
                 "virtual-video-devices"     : self.virtual_video_devices}
 
     def do_get_info(self, proto, server_sources=None, window_ids=None):
-        info = {"server.python.version" : python_platform.python_version()}
+        info = {"server" : {"python" : {"version" : python_platform.python_version()}}}
 
         def up(prefix, d, suffix=""):
             updict(info, prefix, d, suffix)
@@ -1870 +1869 @@
 
         info["windows"] = len([window for window in list(self._id_to_window.values()) if window.is_managed()])
         # other clients:
-        info["clients"] = len([p for p in self._server_sources.keys() if p!=proto])
-        info["clients.unauthenticated"] = len([p for p in self._potential_protocols if ((p is not proto) and (p not in self._server_sources.keys()))])
+        info["clients"] = {""                   : len([p for p in self._server_sources.keys() if p!=proto]),
+                           "unauthenticated"    : len([p for p in self._potential_protocols if ((p is not proto) and (p not in self._server_sources.keys()))])}
         #find the server source to report on:
         n = len(server_sources or [])
         if n==1:
@@ -1879 +1878 @@
             up("client", ss.get_info())
             info.update(ss.get_window_info(window_ids))
         elif n>1:
+            cinfo = {}
             for i, ss in enumerate(server_sources):
-                up("client[%i]" % i, ss.get_info())
-                wi = ss.get_window_info(window_ids)
-                up("client[%i]" % i, wi)
-                #this means that the last source overrides previous ones
-                #(bad decision was made on the namespace for this..)
-                info.update(wi)
+                sinfo = ss.get_info()
+                sinfo.update(ss.get_window_info(window_ids))
+                cinfo[i] = sinfo
+            up("client", cinfo)
         return info
 
     def add_windows_info(self, info, window_ids):
+        winfo = {}
         for wid, window in self._id_to_window.items():
             if window_ids is not None and wid not in window_ids:
                 continue
-            for k,v in self.get_window_info(window).items():
-                wp = "window[%s]." % wid
-                info[wp + k] = v
+            winfo[wid] = self.get_window_info(window)
+        updict(info, "window", winfo)
 
     def get_window_info(self, window):
         from xpra.server.source import make_window_metadata

xpra/server/server_core.py

@@ -40 +40 @@
 from xpra.make_thread import make_thread
 from xpra.scripts.fdproxy import XpraProxy
 from xpra.server.control_command import ControlError, HelloCommand, HelpCommand, DebugControl
-from xpra.util import csv, typedict, updict, repr_ellipsized, dump_all_frames, \
+from xpra.util import csv, typedict, updict, flatten_dict, repr_ellipsized, dump_all_frames, \
         SERVER_SHUTDOWN, SERVER_UPGRADE, LOGIN_TIMEOUT, DONE, PROTOCOL_ERROR, SERVER_ERROR, VERSION_ERROR, CLIENT_REQUEST
 
 main_thread = threading.current_thread()
@@ -877 +877 @@
         self.get_all_info(self.do_send_info, proto)
 
     def do_send_info(self, proto, info):
-        proto.send_now(("hello", info))
+        proto.send_now(("hello", flatten_dict(info)))
 
     def get_all_info(self, callback, proto=None, *args):
         ui_info = self.get_ui_info(proto, *args)
@@ -928 +928 @@
                 "executable"        : sys.executable,
                 })
         if self.session_name:
-            info["session.name"] = self.session_name
+            info["session"] = {"name" : self.session_name}
         if self.child_reaper:
             info.update(self.child_reaper.get_info())
         return info

xpra/server/source.py

@@ -41 +41 @@
 from xpra.make_thread import make_thread
 from xpra.os_util import platform_name, Queue, get_machine_id, get_user_uuid
 from xpra.server.background_worker import add_work_item
-from xpra.util import csv, std, typedict, updict, get_screen_info, CLIENT_PING_TIMEOUT, WORKSPACE_UNSET, DEFAULT_METADATA_SUPPORTED
+from xpra.util import csv, std, typedict, updict, flatten_dict, get_screen_info, CLIENT_PING_TIMEOUT, WORKSPACE_UNSET, DEFAULT_METADATA_SUPPORTED
 
 
 NOYIELD = os.environ.get("XPRA_YIELD") is None
@@ -1350 +1350 @@
                 "suspended"         : self.suspended,
                 }
         if self.desktop_size_unscaled:
-            info["desktop_size.unscaled"] = self.desktop_size_unscaled
+            info["desktop_size"] = {"unscaled" : self.desktop_size_unscaled}
 
         def addattr(k, name):
             v = getattr(self, name)
@@ -1360 +1360 @@
             addattr(x, "client_"+x)
         #encoding:
         info.update({
-             "encodings"         : self.encodings,
-             "encodings.core"    : self.core_encodings,
-             "encoding.default"  : self.default_encoding or ""
+             "encodings"         : {""      : self.encodings,
+                                    "core"  : self.core_encodings},
              })
+        info.setdefault("encoding", {})["default"] = self.default_encoding or ""
         def up(prefix, d):
             updict(info, prefix, d)
         up("encoding",      self.default_encoding_options)
@@ -1370 +1370 @@
         up("encoding",      self.encoding_options)
         up("icons",         self.icons_encoding_options)
         up("connection",    self.protocol.get_info())
-        up("av-sync",       {"client.delay"         : self.av_sync_delay,
+        up("av-sync",       {"client"               : {"delay"  : self.av_sync_delay},
                              "total"                : self.av_sync_delay_total,
                              "delta"                : self.av_sync_delta})
         if self.window_frame_sizes:
-            up("window.frame-sizes", self.window_frame_sizes)
+            up("window", {"frame-sizes" : self.window_frame_sizes})
         if self.window_filters:
             i = 0
+            finfo = {}
             for uuid, f in self.window_filters:
                 if uuid==self.uuid:
-                    info["window-filter[%i]" % i] = str(f)
+                    finfo[i] = str(f)
                     i += 1
+            up("window-filter", finfo)
         info.update(self.get_sound_info())
         info.update(self.get_features_info())
         info.update(self.get_screen_info())
@@ -1425 +1427 @@
             v = getattr(self, prop)
             if v is not None:
                 info[prop] = v
-        for k,v in sound_info(self.supports_speaker, self.sound_source).items():
-            info["speaker.%s" % k] = v
-        for k,v in sound_info(self.supports_microphone, self.sound_sink).items():
-            info["microphone.%s" % k] = v
+        updict(info, "speaker",     sound_info(self.supports_speaker, self.sound_source))
+        updict(info, "microphone",  sound_info(self.supports_microphone, self.sound_sink))
         return info
 
     def get_window_info(self, window_ids=[]):
@@ -1435 +1435 @@
         """
             Adds encoding and window specific information
         """
-        info = {
-            "damage.compression_queue.size.current" : self.encode_work_queue.qsize(),
-            "damage.packet_queue.size.current"      : len(self.packet_queue),
-            }
+        info = {"damage"    : {
+                               "compression_queue"  : {"size" : {"current" : self.encode_work_queue.qsize()}},
+                               "packet_queue"       : {"size" : {"current" : len(self.packet_queue)}},
+                               }
+                }
         qpixels = [x[2] for x in list(self.packet_queue)]
         add_list_stats(info, "packet_queue_pixels",  qpixels)
         if len(qpixels)>0:
-            info["packet_queue_pixels.current"] = qpixels[-1]
+            info["packet_queue_pixels"] = {"current" : qpixels[-1]}
 
         info.update(self.statistics.get_info())
 
@@ -1450 +1451 @@
             total_pixels = 0
             total_time = 0.0
             in_latencies, out_latencies = [], []
+            winfo = {}
             for wid in window_ids:
                 ws = self.window_sources.get(wid)
                 if ws is None:
                     continue
                 #per-window source stats:
-                updict(info, "window[%i]" % wid, ws.get_info())
+                winfo[wid] = ws.get_info()
                 #collect stats for global averages:
                 for _, _, pixels, _, _, encoding_time in list(ws.statistics.encoding_stats):
                     total_pixels += pixels
@@ -1462 +1464 @@
                     total_time += encoding_time
                 in_latencies += [x*1000 for _, _, _, x in list(ws.statistics.damage_in_latency)]
                 out_latencies += [x*1000 for _, _, _, x in list(ws.statistics.damage_out_latency)]
+            updict(info, "window", winfo)
             v = 0
             if total_time>0:
                 v = int(total_pixels / total_time)
-            info["encoding.pixels_encoded_per_second"] = v
+            info.setdefault("encoding", {})["pixels_encoded_per_second"] = v
             add_list_stats(info, "damage.in_latency",  in_latencies, show_percentile=[9])
             add_list_stats(info, "damage.out_latency",  out_latencies, show_percentile=[9])
         updict(info, "batch", self.global_batch_config.get_info())
@@ -1473 +1476 @@
 
 
     def send_info_response(self, info):
-        self.send("info-response", info)
+        self.send("info-response", flatten_dict(info))
 
 
     def send_server_event(self, *args):

xpra/server/source_stats.py

@@ -144 +144 @@
 
 
     def get_info(self):
-        info = {
-            "damage.events"                     : self.damage_events_count,
-            "damage.packets_sent"               : self.packet_count,
-            "encoding.decode_errors"            : self.decode_errors,
+        info = {"damage" : {
+                            "events"        : self.damage_events_count,
+                            "packets_sent"  : self.packet_count,
+                            },
+                "encoding" : {"decode_errors"   : self.decode_errors},
             }
         qsizes = [x for _,x in list(self.compression_work_qsizes)]
         add_list_stats(info, "damage.data_queue.size",  qsizes)

xpra/server/window/window_source.py

@@ -318 +318 @@
         """
         info = {
                 "dimensions"            : self.window_dimensions,
-                "encoding"              : self.encoding,
                 "suspended"             : self.suspended or False
                 }
         def up(prefix, d):
@@ -327 +326 @@
         up("av-sync",       {"current"  : self.av_sync_delay,
                              "target"   : self.av_sync_delay_target})
         #heuristics
-        up("encoding.lossless_threshold", {
-                "base"                  : self._lossless_threshold_base,
-                "pixel_boost"           : self._lossless_threshold_pixel_boost})
+        up("encoding", {""                      : self.encoding,
+                        "lossless_threshold"    : {
+                                                   "base"           : self._lossless_threshold_base,
+                                                   "pixel_boost"    : self._lossless_threshold_pixel_boost}
+                        })
+        now = time.time()
+        buckets_info = {}
+        for i,x in enumerate(self.delta_pixel_data):
+            if x:
+                w, h, pixel_format, coding, store, buflen, _, hits, last_used = x
+                buckets_info[i] = w, h, pixel_format, coding, store, buflen, hits, int((now-last_used)*1000)
         up("encoding", {
                 "rgb_threshold"         : self._rgb_auto_threshold,
                 "mmap"                  : bool(self._mmap) and (self._mmap_size>0),
@@ -336 +343 @@
                 "last_used"             : self.encoding_last_used or "",
                 "full-frames-only"      : self.full_frames_only,
                 "supports-transparency" : self.supports_transparency,
-                "delta"                 : self.supports_delta,
-                "delta.buckets"         : self.delta_buckets,
+                "delta"                 : {""           : self.supports_delta,
+                                           "buckets"    : self.delta_buckets,
+                                           "bucket"     : buckets_info,
+                                           },
                 })
         if self.pixel_format:
             info["pixel-format"] = self.pixel_format
-        now = time.time()
-        for i,x in enumerate(self.delta_pixel_data):
-            if x:
-                w, h, pixel_format, coding, store, buflen, _, hits, last_used = x
-                info["encoding.delta.bucket[%s]" % i] = w, h, pixel_format, coding, store, buflen, hits, int((now-last_used)*1000)
         up("encoding",  self.get_quality_speed_info())
         try:
             #ie: get_strict_encoding -> "strict_encoding"
-            info["encoding.selection"] = self.get_best_encoding.__name__.replace("get_", "")
+            info["encoding"]["selection"] = self.get_best_encoding.__name__.replace("get_", "")
         except:
             pass
         up("property",  self.get_property_info())
@@ -366 +370 @@
                  })
         larm = self.last_auto_refresh_message
         if larm:
-            up("encodings.auto-refresh.last-event", {
-                "elapsed"               : int(1000*(time.time()-larm[0])),
-                "message"               : larm[1],
-                                                     })
+            up("encodings", {"auto-refresh" : {"last-event" : {
+                                                              "elapsed" : int(1000*(time.time()-larm[0])),
+                                                              "message" : larm[1],
+                                                              }
+                                              }
+                             })
         up("icons", self.icons_encoding_options)
         idata = self.window_icon_data
         if idata:

xpra/server/window/window_stats.py

@@ -153 +153 @@
 
 
     def get_info(self):
-        info = {
-                "damage.events"         : self.damage_events_count,
-                "damage.packets_sent"   : self.packet_count}
+        info = {"damage"    : {"events"         : self.damage_events_count,
+                               "packets_sent"   : self.packet_count}
+                }
         #encoding stats:
         if len(self.encoding_stats)>0:
             estats = list(self.encoding_stats)

xpra/server/window/window_video_source.py

@@ -158 +158 @@
         if ve:
             info["encoder"] = ve.get_type()
             up("encoder", ve.get_info())
-        up("encoding.pipeline_param", self.get_pipeline_info())
-        info["encodings.non-video"] = self.non_video_encodings
-        info["encodings.edge"] = self.edge_encoding or ""
+        info["encodings"] = {"non-video"    : self.non_video_encodings,
+                             "edge"         : self.edge_encoding or ""}
+        einfo = {"pipeline_param" : self.get_pipeline_info()}
         if self._last_pipeline_check>0:
-            info["encoding.pipeline_last_check"] = int(1000*(time.time()-self._last_pipeline_check))
+            einfo["pipeline_last_check"] = int(1000*(time.time()-self._last_pipeline_check))
         lps = self.last_pipeline_scores
         if lps:
+            popts = {}
             for i, lp in enumerate(lps):
-                up("encoding.pipeline_option[%s]" % i, self.get_pipeline_score_info(*lp))
+                popts[i] = self.get_pipeline_score_info(*lp)
+            einfo["pipeline_option"] = popts
+        up("encoding", einfo)
         return info
 
     def get_pipeline_info(self):

xpra/simple_stats.py

@@ -7 +7 @@
 # Simple statistical functions
 
 from math import sqrt, pow
+from xpra.util import updict
 
 def to_std_unit(v, unit=1000):
     if v>=unit**3:
@@ -69 +70 @@
     return values_to_scaled_values(absolute_to_diff_values(data), scale_unit=scale_unit, min_scaled_value=min_scaled_value, num_values=num_values)
 
 def add_weighted_list_stats(info, basename, weighted_values, show_percentile=False):
+    updict(info, basename, get_weighted_list_stats(weighted_values, show_percentile))
+
+def get_weighted_list_stats(weighted_values, show_percentile=False):
     values = [x for x, _ in weighted_values]
     if len(values)==0:
-        return
-    info["%s.min" % basename] = int(min(values))
-    info["%s.max" % basename] = int(max(values))
+        return {}
     #weighted mean:
     tw = 0
     tv = 0
@@ -81 +83 @@
         tw += w
         tv += v * w
     avg = tv/tw
-    info["%s.avg" % basename] = int(avg)
+    stats = {
+             "min"   : int(min(values)),
+             "max"   : int(max(values)),
+             "avg"   : int(avg),
+             }
     if show_percentile:
         #percentile
         svalues = sorted(values)
@@ -88 +94 @@
         for i in range(1,10):
             pct = i*10
             index = len(values)*i//10
-            info["%s.%sp" % (basename, pct)] = int(svalues[index])
+            stats["%ip" % pct] = int(svalues[index])
+    return stats
 
+
 def find_invpow(x, n):
     """Finds the integer component of the n'th root of x,
     an integer such that y ** n <= x < (y + 1) ** n.
@@ -109 +117 @@
     return mid + 1
 
 def add_list_stats(info, basename, in_values, show_percentile=[5, 8, 9], show_dev=False):
+    updict(info, basename, get_list_stats(in_values, show_percentile, show_dev))
+
+def get_list_stats(in_values, show_percentile=[5, 8, 9], show_dev=False):
     #this may be backed by a deque/list whichi is used by other threads
     #so make a copy before use:
     values = list(in_values)
     if len(values)==0:
-        return
-    info["%s.cur" % basename] = int(values[-1])
-    info["%s.min" % basename] = int(min(values))
-    info["%s.max" % basename] = int(max(values))
+        return  {}
     #arithmetic mean
     avg = sum(values)/len(values)
-    info["%s.avg" % basename] = int(avg)
+    lstats = {
+              "cur"       : int(values[-1]),
+              "min"       : int(min(values)),
+              "max"       : int(max(values)),
+              "avg"       : int(avg),
+              }
     if show_dev:
         p = 1           #geometric mean
         h = 0           #harmonic mean
@@ -133 +146 @@
             var += (x-avg)**2
         #standard deviation:
         std = sqrt(var/len(values))
-        info["%s.std" % basename] = int(std)
+        lstats["std"] = int(std)
         if avg!=0:
             #coefficient of variation
-            info["%s.cv_pct" % basename] = int(100.0*std/avg)
+            lstats["cv_pct"] = int(100.0*std/avg)
         if counter>0 and p<float('inf'):
             #geometric mean
             try:
@@ -143 +156 @@
                 v = int(pow(p, 1.0/counter))
             except OverflowError:
                 v = find_invpow(p, counter)
-            info["%s.gm" % basename] = v
+            lstats["gm"] = v
         if h!=0:
             #harmonic mean
-            info["%s.h" % basename] = int(counter/h)
+            lstats["h"] = int(counter/h)
     if show_percentile:
         #percentile
         svalues = sorted(values)
@@ -153 +166 @@
         for i in show_percentile:
             pct = i*10
             index = len(values)*i//10
-            info["%s.%sp" % (basename, pct)] = int(svalues[index])
+            lstats["%ip" % pct] = int(svalues[index])
+    return lstats

xpra/sound/pulseaudio/pulseaudio_pactl_util.py

@@ -9 +9 @@
 
 from xpra.sound.pulseaudio.pulseaudio_common_util import get_pulse_server_x11_property, get_pulse_id_x11_property
 from xpra.scripts.exec_util import safe_exec
-from xpra.util import nonl
+from xpra.util import nonl, updict
 
 from xpra.log import Logger
 log = Logger("sound")
@@ -174 +174 @@
 
 
 def get_info():
-    info = {
-            "pulseaudio.wrapper": "pactl",
-            "pulseaudio.found"  : has_pa(),
-            "pulseaudio.id"     : get_pulse_id(),
-            "pulseaudio.server" : get_pulse_server(False),
-           }
+    info = {}
+    updict(info, "pulseaudio", {
+                                "wrapper"   : "pactl",
+                                "found"     : has_pa(),
+                                "id"        : get_pulse_id(),
+                                "server"    : get_pulse_server(False),
+                                })
     i = 0
+    dinfo = {}
     for monitors in (True, False):
         for io in (True, False):
             devices = get_pa_device_options(monitors, io, log_errors=False)
             for d,name in devices.items():
-                info["device.%s" % d] = name
+                dinfo[d] = name
                 i += 1
+    info["device"] = dinfo
     info["devices"] = i
     return info
 

xpra/sound/src.py

@@ -173 +173 @@
         if self.caps:
             info["caps"] = self.caps
         if self.queue:
-            info["queue.cur"] = self.queue.get_property("current-level-time")//MS_TO_NS
+            info["queue"] = {"cur" : self.queue.get_property("current-level-time")//MS_TO_NS}
         if self.buffer_latency:
             for x in ("actual-buffer-time", "actual-latency-time"):
                 v = self.src.get_property(x)

xpra/util.py

@@ -500 +500 @@
     return int(v+0.5)
 
 
+
+def flatten_dict(info):
+    to = {}
+    def add_dict(path, d):
+        for k,v in d.items():
+            if path:
+                npath = path+"."+str(k)
+            else:
+                npath = str(k)
+            if isinstance(v, dict):
+                add_dict(npath, v)
+            elif v is not None:
+                to[npath] = v
+    add_dict(None, info)
+    return to
+
 #used for merging dicts with a prefix and suffix
 #non-None values get added to <todict> with a prefix and optional suffix
 def updict(todict, prefix, d, suffix=""):

xpra/x11/server.py

@@ -290 +290 @@
         info["focused"] = self._has_focus
         info["grabbed"] = self._has_grab
         log("do_get_info: adding cursor=%s", self.last_cursor_data)
+        updict(info, "cursor", self.get_cursor_info())
+        return info
+
+    def get_cursor_info(self):
+        #(NOT from UI thread)
         #copy to prevent race:
         cd = self.last_cursor_data
         if cd is None:
-            info["cursor"] = "None"
-        else:
-            info["cursor.is_default"] = bool(self.default_cursor_data and len(self.default_cursor_data)>=8 and len(cd)>=8 and cd[7]==cd[7])
-            #all but pixels:
-            for i, x in enumerate(("x", "y", "width", "height", "xhot", "yhot", "serial", None, "name")):
-                if x:
-                    v = cd[i] or ""
-                    info["cursor." + x] = v
-        return info
+            return {"" : "None"}
+        cinfo = {"is_default"   : bool(self.default_cursor_data and len(self.default_cursor_data)>=8 and len(cd)>=8 and cd[7]==cd[7])}
+        #all but pixels:
+        for i, x in enumerate(("x", "y", "width", "height", "xhot", "yhot", "serial", None, "name")):
+            if x:
+                v = cd[i] or ""
+                cinfo[x] = v
+        return cinfo
 
     def get_ui_info(self, proto, wids=None, *args):
         info = X11ServerBase.get_ui_info(self, proto, wids, *args)
@@ -309 +313 @@
         wm = self._wm
         if wm:
             info["window-manager-name"] = wm.get_net_wm_name()
+        info.setdefault("cursor", {}).update(self.get_ui_cursor_info())
+        return info
+
+    def get_ui_cursor_info(self):
+        #(from UI thread)
         #now cursor size info:
         display = gtk.gdk.display_get_default()
         pos = display.get_default_screen().get_root_window().get_pointer()[:2]
-        info["cursor.position"] = pos
+        cinfo = {"position" : pos}
         for prop, size in {"default" : display.get_default_cursor_size(),
                            "max"     : display.get_maximal_cursor_size()}.items():
             if size is None:
                 continue
-            info["cursor.%s_size" % prop] = size
-        return info
+            cinfo["%s_size" % prop] = size
+        return cinfo
 
 
     def get_window_info(self, window):
         info = X11ServerBase.get_window_info(self, window)
-        info["focused"] = self._has_focus and self._window_to_id.get(window, -1)==self._has_focus
-        info["grabbed"] = self._has_grab and self._window_to_id.get(window, -1)==self._has_grab
-        info["geometry"] = window.get_property("geometry")
-        info["shown"] = self._desktop_manager.is_shown(window)
+        info.update({
+                     "focused"  : self._has_focus and self._window_to_id.get(window, -1)==self._has_focus,
+                     "grabbed"  : self._has_grab and self._window_to_id.get(window, -1)==self._has_grab,
+                     "geometry" : window.get_property("geometry"),
+                     "shown"    : self._desktop_manager.is_shown(window),
+                     })
         try:
             info["client-geometry"] = self._desktop_manager.window_geometry(window)
         except:

xpra/x11/server_keyboard_config.py

@@ -12 +12 @@
 log = Logger("keyboard")
 
 
-from xpra.util import csv
+from xpra.util import csv, updict
 from xpra.gtk_common.keymap import get_gtk_keymap
 from xpra.x11.gtk_x11.keys import grok_modifier_map
 from xpra.keyboard.mask import DEFAULT_MODIFIER_NUISANCE, DEFAULT_MODIFIER_NUISANCE_KEYNAMES, mask_to_names
@@ -65 +65 @@
 
     def get_info(self):
         info = KeyboardConfigBase.get_info(self)
-        info["modifiers.filter"] = self.modifiers_filter
         #keycodes:
         if self.keycode_translation:
             for kc, keycode in self.keycode_translation.items():
@@ -82 +81 @@
                 info["keymap.%s" % i] = (keyval, name, keycode, group, level)
                 i += 1
         #modifiers:
+        modinfo = {}
+        modsinfo = {}
+        modinfo["filter"] = self.modifiers_filter
         if self.modifier_client_keycodes:
             for mod, keys in self.modifier_client_keycodes.items():
-                info["modifier." + mod + ".client_keys"] = keys
+                modinfo.setdefault(mod, {})["client_keys"] = keys
         if self.keynames_for_mod:
             for mod, keys in self.keynames_for_mod.items():
-                info["modifier." + mod + ".keys"] = tuple(keys)
+                modinfo.setdefault(mod, {})["keys"] = tuple(keys)
         if self.keycodes_for_modifier_keynames:
             for mod, keys in self.keycodes_for_modifier_keynames.items():
-                info["modifier." + mod + ".keycodes"] = tuple(keys)
+                modinfo.setdefault(mod, {})["keycodes"] = tuple(keys)
         if self.xkbmap_mod_meanings:
             for mod, mod_name in self.xkbmap_mod_meanings.items():
-                info["modifier." + mod ] = mod_name
-        if self.xkbmap_x11_keycodes:
-            for keycode, keysyms in self.xkbmap_x11_keycodes.items():
-                info["x11_keycode." + str(keycode) ] = keysyms
+                modinfo[mod] = mod_name
+        updict(info, "x11_keycode", self.xkbmap_x11_keycodes)
         for x in ("print", "layout", "variant"):
             v = getattr(self, "xkbmap_"+x)
             if v:
@@ -104 +104 @@
         for x in ("nuisance", ):
             v = getattr(self, "xkbmap_mod_"+x)
             if v:
-                info["modifiers."+x] = list(v)
+                modsinfo[x] = list(v)
         for x in ("managed", "pointermissing"):
             v = getattr(self, "xkbmap_mod_"+x)
             if v:
-                info["modifiers."+x] = v
+                modsinfo[x] = v
+        updict(info, "modifier", modinfo)
+        updict(info, "modifiers", modsinfo)
         log("keyboard info: %s", "\n".join(["%s=%s" % (k,v) for k,v in info.items()]))
         return info
 

xpra/x11/shadow_x11_server.py

@@ -95 +95 @@
 
     def get_info(self, proto):
         info = X11ServerBase.get_info(self, proto)
-        info["features.shadow"] = True
-        info["server.type"] = "Python/gtk2/x11-shadow"
+        info.setdefault("features", {})["shadow"] = True
+        info.setdefault("server", {})["type"] = "Python/gtk2/x11-shadow"
         return info

xpra/x11/x11_server_base.py

@@ -127 +127 @@
                     v = parts[1].strip()
                     self.opengl_props[k] = v
             else:
-                self.opengl_props["error"] = str(err)
+                self.opengl_props["error"] = str(err).strip("\n\r")
         except Exception as e:
             gllog.warn("Warning: failed to query OpenGL properties")
             gllog.warn(" %s", e)
@@ -218 +218 @@
         info = GTKServerBase.do_get_info(self, proto, server_sources, window_ids)
         if self.opengl_props:
             updict(info, "opengl", self.opengl_props)
-        info["server.type"] = "Python/gtk/x11"
+        #this is added here because the server keyboard config doesn't know about "keys_pressed"..
+        updict(info, "keyboard", {
+                                  "state"           : {"keys_pressed"   : list(self.keys_pressed.keys())},
+                                  "fast-switching"  : True,
+                                  })
         try:
+            fx = find_libfakeXinerama()
+        except:
+            fx = None
+        sinfo = {"type"             : "Python/gtk/x11",
+                 "fakeXinerama"     : self.fake_xinerama and bool(fx),
+                 "libfakeXinerama"  : fx or "",
+                 "Xkb"              : X11Keyboard.hasXkb(),
+                 "XTest"            : X11Keyboard.hasXTest()}
+        try:
             from xpra.x11.gtk2.composite import CompositeHelper
-            info["server.XShm"] = CompositeHelper.XShmEnabled
+            sinfo["XShm"] = CompositeHelper.XShmEnabled
         except:
             pass
         #randr:
@@ -228 +241 @@
         try:
             sizes = RandR.get_screen_sizes()
             if self.randr and len(sizes)>=0:
-                info["server.randr.options"] = list(reversed(sorted(sizes)))
+                sinfo["randr"] = {"options" : list(reversed(sorted(sizes)))}
         except:
             pass
-        try:
-            fx = find_libfakeXinerama()
-        except:
-            fx = None
-        info["server.fakeXinerama"] = self.fake_xinerama and bool(fx)
-        info["server.libfakeXinerama"] = fx or ""
-        #this is added here because the server keyboard config doesn't know about "keys_pressed"..
-        info["keyboard.state.keys_pressed"] = list(self.keys_pressed.keys())
-        info["keyboard.fast-switching"] = True
-        info["server.Xkb"] = X11Keyboard.hasXkb()
-        info["server.XTest"] = X11Keyboard.hasXTest()
+        updict(info, "server", sinfo)
         return info
 
     def get_window_info(self, window):