Ticket #229: gl-yuv-cython-fix.patch

xpra/gl/gl_window_backing.py

@@ -128 +128 @@
             glFlush()
         drawable.gl_end()
 
+    def cairo_draw(self, context):
+        drawable = self.gl_init()
+        if drawable:
+            try:
+                self.do_cairo_draw(context, drawable)
+            finally:
+                self.gl_end(drawable)
+
     def gl_expose_event(self, glarea, event):
         debug("gl_expose_event(%s, %s)", glarea, event)
         area = event.area
@@ -146 +154 @@
 
     def do_video_paint(self, coding, img_data, x, y, w, h, options, callbacks):
         debug("do_video_paint: options=%s, decoder=%s", options, type(self._video_decoder))
-        err, rowstrides, img_data = self._video_decoder.decompress_image_to_yuv(img_data, options)
+        YUVImage = self._video_decoder.decompress_image_to_yuv(img_data, options)
         csc_pixel_format = options.get("csc_pixel_format", -1)
         #this needs to be done here so we still hold the video_decoder lock:
         pixel_format = self._video_decoder.get_pixel_format(csc_pixel_format)
-        success = err==0 and img_data and len(img_data)==3
-        if not success:
-            log.error("do_video_paint: %s decompression error %s on %s bytes of picture data for %sx%s pixels, options=%s",
-                      coding, err, len(img_data), w, h, options)
+        if YUVImage is None:
+            log.error("do_video_paint: %s decompression error on %s bytes of picture data for %sx%s pixels, options=%s",
+                      coding, len(img_data), w, h, options)
             gobject.idle_add(fire_paint_callbacks, callbacks, False)
             return
-        gobject.idle_add(self.do_gl_paint, x, y, w, h, img_data, rowstrides, pixel_format, callbacks)
+        gobject.idle_add(self.do_gl_paint, x, y, w, h, YUVImage, pixel_format, callbacks)
 
-    def do_gl_paint(self, x, y, w, h, img_data, rowstrides, pixel_format, callbacks):
+    def do_gl_paint(self, x, y, w, h, YUVImage, pixel_format, callbacks):
         #this function runs in the UI thread, no video_decoder lock held
         drawable = self.gl_init()
         if not drawable:
@@ -167 +174 @@
             return
         try:
             try:
-                self.update_texture_yuv(img_data, x, y, w, h, rowstrides, pixel_format)
+                self.update_texture_yuv(YUVImage, x, y, w, h, pixel_format)
                 if self.paint_screen:
                     self.render_image(x, y, x+w, y+h)
                 fire_paint_callbacks(callbacks, True)
@@ -189 +196 @@
             return (1, 1), (1, 1), (1, 1)
         raise Exception("invalid pixel format: %s" % pixel_format)
 
-    def update_texture_yuv(self, img_data, x, y, width, height, rowstrides, pixel_format):
+    def update_texture_yuv(self, YUVImage, x, y, width, height, pixel_format):
         window_width, window_height = self.size
         assert self.textures is not None, "no OpenGL textures!"
 
@@ -238 +245 @@
             (div_w, div_h) = divs[index]
             glActiveTexture(texture)
             glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
-            glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[index])
-            glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width/div_w, height/div_h, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[index])
+            rowstride = YUVImage.get_rowstride(index)
+            glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstride)
+            pixel_data = YUVImage.get_component(index)
+            glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width/div_w, height/div_h, GL_LUMINANCE, GL_UNSIGNED_BYTE, pixel_data)
             if index == 1:
                 U_width = width/div_w
                 U_height = height/div_h
@@ -248 +257 @@
                     log.error("Width of V plane is %d, differs from width of corresponding U plane (%d), pixel_format is %d", width/div_w, U_width, pixel_format)
                 if height/div_h != U_height:
                     log.error("Height of V plane is %d, differs from height of corresponding U plane (%d)", height/div_h, U_height)
+        del YUVImage
 
     def render_image(self, rx, ry, rw, rh):
         debug("render_image %sx%s at %sx%s pixel_format=%s", rw, rh, rx, ry, self.pixel_format)

xpra/vpx/codec.pyx

@@ -6 +6 @@
 import os
 from libc.stdlib cimport free
 
+cdef extern from "string.h":
+    void * memcpy ( void * destination, void * source, size_t num )
+    void * memset ( void * ptr, int value, size_t num )
+
 cdef extern from "Python.h":
     ctypedef int Py_ssize_t
     ctypedef object PyObject
@@ -81 +85 @@
     def __dealloc__(self):                  #@DuplicatedSignature
         self.free()
 
+cdef class YUVImage:
+    cdef uint8_t *y
+    cdef uint8_t *u
+    cdef uint8_t *v
+    cdef int ystride
+    cdef int ustride
+    cdef int vstride
+    cdef int height
 
+    cdef uint8_t* copy(self, uint8_t *src, long size):
+        cdef uint8_t *dst
+        dst = <uint8_t*> xmemalign(size+1024)
+        memcpy(dst, src, size)
+        return dst
+
+    cdef init(self, uint8_t *y, int ystride, uint8_t *u, int ustride, uint8_t *v, int vstride, int height):
+        print("new YUVImage(%s, %s, %s, %s)" % (ystride, ustride, vstride, height))
+        self.height = height
+        self.ystride = ystride
+        self.ustride = ustride
+        self.vstride = vstride
+        self.y = self.copy(y, height * ystride)
+        self.u = self.copy(u, height * ustride)
+        self.v = self.copy(v, height * vstride)
+        print("new YUVImage(%s, %s, %s, %s) done" % (ystride, ustride, vstride, height))
+
+    cdef free(self):                        #@DuplicatedSignature
+        print("YUVImage.free()")
+        xmemfree(self.y)
+        xmemfree(self.u)
+        xmemfree(self.v)
+        self.y = NULL
+        self.u = NULL
+        self.v = NULL
+
+    def get_component(self, index):
+        #doutvY = (<char *>dout[0])[:self.height * outstrides[0]]
+        if index==0:
+            return (<char *> self.y)[:self.height * self.ystride]
+        elif index==1:
+            return (<char *> self.u)[:self.height * self.ustride]
+        elif index==2:
+            return (<char *> self.v)[:self.height * self.vstride]
+        else:
+            raise Exception("invalid component index %s" % index)
+
+    def get_rowstride(self, index):         #@DuplicatedSignature
+        if index==0:
+            return self.ystride
+        elif index==1:
+            return self.ustride
+        elif index==2:
+            return self.vstride
+        else:
+            raise Exception("invalid component index %s" % index)
+
+    def __dealloc__(self):                  #@DuplicatedSignature
+        self.free()
+
+
 cdef class Decoder(xcoder):
 
     def init_context(self, width, height, use_swscale, options):
@@ -104 +167 @@
         PyObject_AsReadBuffer(input, <const_void_pp> &buf, &buf_len)
         i = decompress_image(self.context, buf, buf_len, &dout, &outsize, &outstrides)
         if i!=0:
-            return i, [0, 0, 0], ["", "", ""]
-        doutvY = (<char *>dout[0])[:self.height * outstrides[0]]
-        doutvU = (<char *>dout[1])[:self.height * outstrides[1]]
-        doutvV = (<char *>dout[2])[:self.height * outstrides[2]]
-        out = [doutvY, doutvU, doutvV]
-        strides = [outstrides[0], outstrides[1], outstrides[2]]
-        return  i, strides, out
+            return None
+        yuv = YUVImage()
+        yuv.init(dout[0], outstrides[0], dout[1], outstrides[1], dout[2], outstrides[2], self.height)
+        return yuv
 
     def get_pixel_format(self, csc_pixel_format):
         #we only support 420 at present

xpra/window_backing.py

@@ -174 +174 @@
 
 
     def cairo_draw(self, context):
+        self.do_cairo_draw(context, self._backing)
+
+    def do_cairo_draw(self, context, drawable):
         try:
-            context.set_source_pixmap(self._backing, 0, 0)
+            context.set_source_pixmap(drawable, 0, 0)
             context.set_operator(cairo.OPERATOR_SOURCE)
             context.paint()
             return True