Clemens Eisserer

#include <stdio.h>
#include <X11/Xlib.h>
#include <X11/extensions/Xrender.h>
#include <X11/extensions/render.h>
#include <stdlib.h>
#include <math.h>
#include <stdlib.h>
#include <sys/time.h>

#include <xcb/xcb.h>
#include <X11/Xlib-xcb.h>

#include <sys/uio.h>

Display *display;
int screen;
Window root, window;
XEvent event;

Pixmap maskPixmap;
GC maskGC;
Picture maskPicture;

Picture sourcePicture;
int RENDER;


void createMaskTile()
{
    XRenderPictFormat *fmt = XRenderFindStandardFormat(display, PictStandardA8);
    maskPixmap = XCreatePixmap(display, window, 256, 256, 8);

        XGCValues values;
        maskGC = XCreateGC(display, maskPixmap, 0, &values);

    XRenderPictureAttributes pict_attr;
    maskPicture = XRenderCreatePicture(display, maskPixmap, fmt, 0, &pict_attr);
        XRenderColor color_black={.red=0, .green=0, .blue=0, .alpha=0xffff};
        XRenderFillRectangle (display, PictOpClear, maskPicture, &color_black, 0, 0, 512, 512);
}

Picture createPicture()
{
    XRenderPictFormat *fmt = XRenderFindStandardFormat(display, PictStandardRGB24);
    Pixmap sourcePixmap = XCreatePixmap(display, window, 2, 2, 24);
    XRenderPictureAttributes pict_attr;
    pict_attr.repeat=RepeatNone;
    Picture picture = XRenderCreatePicture(display, sourcePixmap, fmt, CPRepeat, &pict_attr);

        XRenderColor yellow={.red=0xffff, .green=0xffff, .blue=0, .alpha=0xffff};
        XRenderFillRectangle (display, PictOpSrc, picture, &yellow, 0, 0, 1000, 1000);

    return picture;
}

static void return_socket(void *closure)
{
  printf("return_socket called!\n");
  fflush(stdout);
}

int putMask(int width, int height, char* data) {

        int paddedWidth = (int) ceil(width / 4.0) * 4;
    int imgDataLengthX = (int) ceil(paddedWidth * height / 4.0);
    int imgBytes = imgDataLengthX * 4;

        unsigned int* req_i = (unsigned int*) data;
        unsigned short* req_s = (unsigned short*) data;
        unsigned char* req_b = (unsigned char*) data;

        req_b[0] = 72; //PutImage
        req_b[1] = 2; //ZPixmap
        req_s[1] = 6 + imgDataLengthX;  //Request-length

        req_i[1] = maskPixmap;
        req_i[2] = XGContextFromGC(maskGC);
        req_s[6] = width;
        req_s[7] = height;
        req_s[8] = 0;
        req_s[9] = 0;

        req_b[20] = 0; //LeftPad
        req_b[21] = 8; //Depth

        req_b[22] = 0; //Pad
        req_b[23] = 0;

        return (6*4 + imgBytes);
}

int fillRect(Picture dst, char* data) {
        unsigned int* req_i = (unsigned int*) data;
        unsigned short* req_s = (unsigned short*) data;
        unsigned char* req_b = (unsigned char*) data;

        req_b[0] = RENDER;
        req_b[1] = 26; //FillRectangles-Opcode
        req_s[1] = 9;  //Request-length

        req_b[4] = 3; //Over

        req_i[2] = dst; //TODO: Wie xid von picture rausfinden

        req_s[6] = 0xffff; //green
        req_s[7] = 0xffff; //Red
        req_s[8] = 0;      //Blue
        req_s[9] = 0xffff; //A

        req_s[10] = 100;
        req_s[11] = 100;
        req_s[12] = 100;
        req_s[13] = 100;

        req_s[14] = 200;
        req_s[15] = 200;
        req_s[16] = 10;
        req_s[17] = 10;

        return 36;
}

int main(int argc, char *argv[])
{
        /*Bosing initialization stuff*/
    display=XOpenDisplay(NULL);

    int render_event_base, render_error_base;
    int render_present=XRenderQueryExtension(display, &render_event_base, &render_error_base);
    if (!render_present) {
        fprintf(stderr, "RENDER extension missing!\n");
        abort();
    }

    XRenderPictFormat *fmt=XRenderFindStandardFormat(display, PictStandardRGB24);
    screen=DefaultScreen(display);
    root=DefaultRootWindow(display);

    window = XCreateWindow(display, root, 0, 0, 640, 480, 0,
        DefaultDepth(display, screen), InputOutput,
        DefaultVisual(display, screen),
        0, NULL);
    XRenderPictureAttributes pict_attr;

    pict_attr.poly_edge=PolyEdgeSmooth;
    pict_attr.poly_mode=PolyModeImprecise;
    Picture picture=XRenderCreatePicture(display, window, fmt, CPPolyEdge|CPPolyMode, &pict_attr);

    XSelectInput(display, window, KeyPressMask|KeyReleaseMask|ExposureMask
        |ButtonPressMask|StructureNotifyMask);


    /* now make the window visible */
    XMapWindow(display, window);

    XRenderColor color_white = {.red=0xffff, .green=0xffff, .blue=0xffff, .alpha=0xffff};

        sourcePicture = createPicture();
        createMaskTile();

       /*Fetch the RENDER extension's opcode*/
       char renderName[] = RENDER_NAME;
       int x;
       XQueryExtension(display, renderName , &RENDER, &x, &x);

       xcb_connection_t* con = XGetXCBConnection(display);

       char* buffer = (char*) malloc(32000);

    while(1) {
        XNextEvent(display, &event);

        switch(event.type) {
            case Expose:
{
                XRenderFillRectangle(display, PictOpOver,
                    picture, &color_white, 0, 0, 1000, 1000);

    int x = 0;
    for(x=0; x < 1000; x++) {
        int flags = 0;
    uint64_t sent;
        xcb_take_socket(con, &return_socket, &flags, flags, &sent);
       // printf("sent: %d\n", sent);fflush(stdout);

        int requests=0;
        int written = 0;
        for(requests = 0; requests < 50; requests++) {
          written += fillRect(picture, &buffer[written]);
        }

        struct iovec vect;
        vect.iov_base = buffer;
        vect.iov_len = written;

        xcb_writev(con, &vect, 1, requests);
    }


                break;
            case DestroyNotify:
                return 0;
        }
    }

}
    return 0;
}