Ticket #147: xpra-vpx-gl.patch

xpra/vpx/codec.pyx

@@ -8 +8 @@
 cdef extern from "Python.h":
     ctypedef int Py_ssize_t
     ctypedef object PyObject
+    ctypedef void** const_void_pp "const void**"
     int PyObject_AsReadBuffer(object obj, void ** buffer, Py_ssize_t * buffer_len) except -1
 
 ctypedef unsigned char uint8_t
@@ -16 +17 @@
 cdef extern from "vpxlib.h":
     vpx_codec_ctx_t* init_encoder(int width, int height)
     void clean_encoder(vpx_codec_ctx_t *context)
-    vpx_image_t* csc_image(vpx_codec_ctx_t *ctx, uint8_t *input, int stride)
+    vpx_image_t* csc_image_rgb2yuv(vpx_codec_ctx_t *ctx, uint8_t *input, int stride)
     int compress_image(vpx_codec_ctx_t *ctx, vpx_image_t *image, uint8_t **out, int *outsz) nogil
 
     vpx_codec_ctx_t* init_decoder(int width, int height)
     void clean_decoder(vpx_codec_ctx_t *context)
-    int decompress_image(vpx_codec_ctx_t *context, uint8_t *input, int size, uint8_t **out, int *outsize, int *outstride)
+    int decompress_image(vpx_codec_ctx_t *ctx, uint8_t *input, int size, uint8_t *(*out)[4], int *outsize, int (*outstride)[4])
+    int csc_image_yuv2rgb(vpx_codec_ctx_t *ctx, uint8_t *input[3], int stride[3], uint8_t **out, int *outsz, int *outstride) nogil
 
 
 ENCODERS = {}
@@ -64 +66 @@
             clean_decoder(self.context)
             self.context = NULL
 
+    def decompress_image_to_yuv(self, input):
+        cdef uint8_t *dout[4]
+        cdef int outsize
+        cdef int outstrides[4]
+        cdef unsigned char * buf = <uint8_t *> 0
+        cdef Py_ssize_t buf_len = 0
+        assert self.context!=NULL
+        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
+
     def decompress_image_to_rgb(self, input):
+        cdef uint8_t *yuvplanes[4]
         cdef uint8_t *dout
         cdef int outsize
+        cdef int yuvstrides[4]
         cdef int outstride
         cdef unsigned char * buf = <uint8_t *> 0
         cdef Py_ssize_t buf_len = 0
+        cdef int i
         assert self.context!=NULL
         assert self.last_image==NULL
-        PyObject_AsReadBuffer(input, <void **>&buf, &buf_len)
-        i = decompress_image(self.context, buf, buf_len, &dout, &outsize, &outstride)
-        self.last_image = dout
+        PyObject_AsReadBuffer(input, <const_void_pp> &buf, &buf_len)
+        print("vpx: before decompress_image")
+        i = decompress_image(self.context, buf, buf_len, &yuvplanes, &outsize, &yuvstrides)
         if i!=0:
             return i, 0, ""
+        for x in xrange(0,4):
+            print("vpx stride[%s]=%s" % (x, yuvstrides[x]))
+            print("vpx out[%s]=%s" % (x, yuvplanes[x][0]))
+        with nogil:
+            i = csc_image_yuv2rgb(self.context, yuvplanes, yuvstrides, &dout, &outsize, &outstride)
+        print("vpx: csc returned %s" % i)
+        if i!=0:
+            return i, 0, ""
+        self.last_image = dout
         doutv = (<char *>dout)[:outsize]
         return  i, outstride, doutv
 
@@ -104 +136 @@
         cdef Py_ssize_t buf_len = 0
         assert self.context!=NULL
         #colourspace conversion with gil held:
-        PyObject_AsReadBuffer(input, <void **>&buf, &buf_len)
-        pic_in = csc_image(self.context, buf, rowstride)
+        PyObject_AsReadBuffer(input, <const_void_pp> &buf, &buf_len)
+        pic_in = csc_image_rgb2yuv(self.context, buf, rowstride)
         assert pic_in!=NULL, "colourspace conversion failed"
         #actual compression (no gil):
         with nogil:

xpra/vpx/vpxlib.c

@@ -30 +30 @@
 #define fourcc    0x30385056
 #define IVF_FILE_HDR_SZ  (32)
 #include <libswscale/swscale.h>
+#include <libavcodec/avcodec.h>
 
 struct vpx_context {
         vpx_codec_ctx_t codec;
@@ -99 +100 @@
         free(ctx);
 }
 
-vpx_image_t* csc_image(struct vpx_context *ctx, const uint8_t *in, int stride)
+vpx_image_t* csc_image_rgb2yuv(struct vpx_context *ctx, const uint8_t *in, int stride)
 {
         vpx_image_t *image = malloc(sizeof(vpx_image_t));
         if (!vpx_img_alloc(image, VPX_IMG_FMT_I420, ctx->width, ctx->height, 1)) {
@@ -144 +145 @@
         return 0;
 }
 
-int decompress_image(struct vpx_context *ctx, uint8_t *in, int size, uint8_t **out, int *outsize, int *outstride)
+int csc_image_yuv2rgb(struct vpx_context *ctx, uint8_t *in[4], const int stride[4], uint8_t **out, int *outsz, int *outstride)
 {
+        AVPicture pic;
+
+        if (!ctx->yuv2rgb)
+                return 1;
+
+        avpicture_fill(&pic, malloc(ctx->height * ctx->width * 3), PIX_FMT_RGB24, ctx->width, ctx->height);
+
+        sws_scale(ctx->yuv2rgb, (const uint8_t * const*) in, stride, 0, ctx->height, pic.data, pic.linesize);
+
+        /* Output (must be freed!) */
+        *out = pic.data[0];
+        *outsz = pic.linesize[0] * ctx->height;
+        *outstride = pic.linesize[0];
+
+        return 0;
+}
+
+int decompress_image(struct vpx_context *ctx, uint8_t *input, int size, uint8_t *(*out)[4], int *outsize, int (*outstride)[4])
+{
         vpx_image_t      *img;
         int frame_sz = size;
         vpx_codec_iter_t  iter = NULL;
-        uint8_t* frame = in;
-        int outstrides[4];
-        uint8_t* outs[4];
         int stride = 0;
         int i = 0;
 
-        if (vpx_codec_decode(&ctx->codec, frame, frame_sz, NULL, 0)) {
+        if (vpx_codec_decode(&ctx->codec, (uint8_t *) input, frame_sz, NULL, 0)) {
                 codec_error(&ctx->codec, "vpx_codec_decode");
                 return -1;
         }
@@ -164 +181 @@
                 codec_error(&ctx->codec, "vpx_codec_get_frame");
                 return -1;
         }
-        for (i=0; i<4; i++)
+        for (i=0; i<4; i++) {
+                *outstride[i] = img->stride[i];
+                *out[i] = img->planes[i];
                 stride += img->stride[i];
+        }
         *outsize = stride * img->h;
-
-        *out = malloc(*outsize);
-        for (i=0; i<4; i++) {
-                outstrides[i] = img->w*3;
-                outs[i] = *out;
-        }
-        sws_scale(ctx->yuv2rgb, img->planes, img->stride, 0, img->h, outs, outstrides);
-        stride = 0;
-        for (i=0; i<4; i++)
-                stride += img->stride[i];
-        *outstride = stride;
         return 0;
 }

xpra/vpx/vpxlib.h

@@ -21 +21 @@
 /** Cleanup decoding context. Must be freed after calling this function. */
 void clean_decoder(struct vpx_context *ctx);
 
-/** Colourspace conversion.
+/** Colorspace conversion.
  * Note: you must call compress_image to free the image buffer.
  @param in: Input buffer, format is packed RGB24.
  @param stride: Input stride (size is taken from context).
  @return: the converted picture.
 */
-vpx_image_t* csc_image(struct vpx_context *ctx, const uint8_t *in, int stride);
+vpx_image_t *csc_image_rgb2yuv(struct vpx_context *ctx, const uint8_t *in, int stride);
 
+/** Colorspace conversion.
+ * Note: you must call compress_image to free the image buffer.
+ @param in: Input picture (3 planes).
+ @param stride: Input strides (3 planes).
+ @param out: Will be set to point to the output data in packed RGB24 format. Must be freed after use by calling free().
+ @param outsz: Will be set to the size of the output buffer.
+ @param outstride: Output stride.
+ @return non zero on error.
+*/
+int csc_image_yuv2rgb(struct vpx_context *ctx, uint8_t *in[3], const int stride[3], uint8_t **out, int *outsz, int *outstride);
+
 /** Compress an image using the given context.
  @param pic_in: the input image, as returned by csc_image
  @param out: Will be set to point to the output data. This output buffer MUST NOT BE FREED and will be erased on the
@@ -40 +51 @@
 /** Decompress an image using the given context.
  @param in: Input buffer, format is H264.
  @param size: Input size.
- @param out: Will be set to point to the output data in RGB24 format.
- @param outstride: Output stride.
+ @param out: Will be filled to point to the output data in planar YUV420 format (4 planes).
+ @param outstride: Output strides. (4 planes)
 */
-int decompress_image(struct vpx_context *ctx, uint8_t *in, int size, uint8_t **out, int *outsize, int *outstride);
+int decompress_image(struct vpx_context *ctx, uint8_t *in, int size, uint8_t *(*out)[4], int *outsize, int (*outstride)[4]);