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

#include <sys/ipc.h>
#include <sys/shm.h>
#include <X11/extensions/XShm.h>


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

XRenderPictFormat *fmtA8;
Pixmap maskPixmap;
Picture alphaMask;
Picture setAlphaPict;
XImage *alphaImg;
XRenderColor clearAlpha = {.red=0, .green=0, .blue=0, .alpha=0};
XRenderColor setAlpha = {.red=0, .green=0, .blue=0, .alpha=0x0fff};
GC alphaGC;
char* alphaData;


Picture create_pen(int red, int green, int blue, int alpha)
{
	XRenderColor color={.red=red, .green=green, .blue=blue, .alpha=alpha};
	XRenderPictFormat *fmt=XRenderFindStandardFormat(display, PictStandardARGB32);
	
	Pixmap pm = XCreatePixmap(display, window, 1, 1, 32);
	XRenderPictureAttributes pict_attr;
	pict_attr.repeat=1;
	Picture picture = XRenderCreatePicture(display, pm, fmt, CPRepeat, &pict_attr);
	XRenderFillRectangle(display, PictOpSrc, picture, &color, 0, 0, 10, 10);
	return picture;
}

Picture createMaskTile()
{
	XRenderPictFormat *fmt = XRenderFindStandardFormat(display, PictStandardA8);
	maskPixmap = XCreatePixmap(display, window, 256, 256, 8);
	XRenderPictureAttributes pict_attr;
	pict_attr.repeat=0;
        pict_attr.component_alpha=0;
	Picture picture = XRenderCreatePicture(display, maskPixmap, fmt, CPRepeat, &pict_attr);
        XRenderColor color_black={.red=0, .green=0, .blue=0, .alpha=0xffff};
        XRenderFillRectangle (display, PictOpClear, picture, &color_black, 0, 0, 32, 32);
      
        XGCValues values;
        alphaGC = XCreateGC(display, maskPixmap, 0, &values);

        alphaData = malloc(32*32);
        alphaImg = XCreateImage(display, &maskPixmap, 8, ZPixmap, 0, alphaData, 32, 32, 8, 0); 

	return picture;
}

void fillRectMaskTile(int trapCnt)
{
  int i;
  XRectangle rects[trapCnt];
  for(i=0; i < trapCnt; i++)
  {
     rects[i].x =      i;     
     rects[i].y =      i;
     rects[i].width  = 80;  
     rects[i].height = 1;                          
  }

  //Render rects to alpha mask
  XRenderFillRectangles (display, PictOpSrc, alphaMask, &setAlpha, &rects[0], 250);
}

void fillTrapMaskTile(int trapCnt)
{
  int i;
  XTrapezoid traps[trapCnt];
  for(i=0; i < trapCnt; i++)  {                  
     int top = i << 16;
     int bottom = (i+1) << 16;
     int left = (100 +i) << 16;
     int right = (200 +i) << 16;

     traps[i].top= top;
     traps[i].bottom=bottom;
     traps[i].left.p1.x=left; traps[i].left.p1.y=top;
     traps[i].left.p2.x=left; traps[i].left.p2.y=bottom;

     traps[i].right.p1.x=right; traps[i].right.p1.y=top;
     traps[i].right.p2.x=right; traps[i].right.p2.y=bottom;
  }
  XRenderCompositeTrapezoids (display, PictOpOver, setAlphaPict, alphaMask, fmtA8, 0, 0, &traps[0], trapCnt);
}

int i=0;
void fillPutImage()
{
  alphaData[(i++) % (32*32)] = 255;

  XPutImage(display, maskPixmap, alphaGC, alphaImg, 0, 0, 0, 0, 32, 32);
}

int usec()
{
  struct timeval tv;
  struct timezone tz;
  struct tm *tm;
  gettimeofday(&tv, &tz);
  tm=localtime(&tv.tv_sec);
  return tv.tv_usec;
}


#define SHM_MASKS 64
Pixmap shmPixmaps[SHM_MASKS];
Picture shmPictures[SHM_MASKS];
XShmSegmentInfo shmInfos[SHM_MASKS];
XImage *shmImages[SHM_MASKS];
GC shmGCs[SHM_MASKS];

void createShmTiles()
{
   XRenderPictFormat *fmt = XRenderFindStandardFormat(display, PictStandardA8);
   XRenderPictureAttributes pict_attr;
   pict_attr.repeat=0;
   pict_attr.component_alpha=0;
   XRenderColor color_black={.red=0, .green=0, .blue=0, .alpha=0xffff};
   XGCValues values;
 
   int i=0;    
   for(; i < SHM_MASKS; i++)
   {
        shmPixmaps[i] = XCreatePixmap(display, window, 32, 32, 8);
	shmPictures[i] = XRenderCreatePicture(display, shmPixmaps[i], fmt, CPRepeat, &pict_attr);
        XRenderFillRectangle (display, PictOpClear, shmPictures[i], &color_black, 0, 0, 32, 32);

        shmGCs[i] = XCreateGC(display, maskPixmap, 0, &values);

        shmImages[i] = XShmCreateImage (display, (Visual*) &shmPixmaps[i], 8, ZPixmap, NULL, &shmInfos[i], 32, 32);

        shmInfos[i].shmid = shmget (IPC_PRIVATE, shmImages[i]->bytes_per_line * shmImages[i]->height, IPC_CREAT|0777);
        shmInfos[i].shmaddr = shmImages[i]->data = shmat (shmInfos[i].shmid, 0, 0);
        shmImages[i]->data = shmInfos[i].shmaddr;
        shmInfos[i].readOnly = False;
        Status shmStat = XShmAttach (display, &shmInfos[i]);
        if(shmStat == 0){printf("Error attching"); fflush(stdout);}
   }
}

int blackit = 0;
int currTile = 0;
int main(int argc, char *argv[])
{
	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();
	}
	
	/* obtain a few parameters */
	XRenderPictFormat *fmt=XRenderFindStandardFormat(display, PictStandardRGB24);
	screen=DefaultScreen(display);
	root=DefaultRootWindow(display);
	
	/* create window and all related resources */
	window = XCreateWindow(display, root, 0, 0, 640, 480, 0,
		DefaultDepth(display, screen), InputOutput,
		DefaultVisual(display, screen), 
		0, NULL);
	XRenderPictureAttributes pict_attr;
	
	/* set picture attributes for anti-aliased edges; default is sharp edges */
	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);
	

	Picture black_pict = create_pen(0,0,0,0xffff);
	
	/* now make the window visible */
	XMapWindow(display, window);
	
	XRenderColor color_white={.red=0xffff, .green=0xffff, .blue=0xffff, .alpha=0xffff};
	XRenderColor color_red={.red=0xffff, .green=0x0000, .blue=0x0000, .alpha=0x0fff};
        XRenderColor color_black={.red=0, .green=0, .blue=0, .alpha=0x0fff};
	Picture black= XRenderCreateSolidFill (display, &color_black);
        Picture red= XRenderCreateSolidFill (display, &color_red);//create_pen(0,0,0,0xffff);
	fmtA8 = XRenderFindStandardFormat(display, PictStandardA8);
	XRenderPictFormat *fmtA1 = XRenderFindStandardFormat(display, PictStandardA1);

        Pixmap pmf = XCreatePixmap(display, window, 100, 100, 24);
	XRenderPictureAttributes pict_attrf;
	pict_attrf.repeat=1;
	Picture picf = XRenderCreatePicture(display, pmf, fmt, CPRepeat, &pict_attrf);

setAlphaPict = create_pen(0,0,0,0xffff);
alphaMask = createMaskTile();

createShmTiles();

/*Zeugs fuer XDrawLine*/
int blackColor = BlackPixel(display, DefaultScreen(display));
GC mgc = XCreateGC(display, maskPixmap, 0, NULL);
XSetForeground(display, mgc, 55);

GC wgc = XCreateGC(display, window, 0, NULL);
XSetForeground(display, wgc, blackColor);


	while(1) {
		XNextEvent(display, &event);
		
		switch(event.type) {
			case Expose:
{
				/* no partial repaints */
				XRenderFillRectangle(display, PictOpOver,
					picture, &color_white, 0, 0, 1000, 1000);

XSync(display, 0);
int stime = usec();
int runs;

for(runs=0; runs < 10000; runs++)
{
   /*Traditional XPutImage based uploading*/
   fillPutImage();
   XRenderComposite(display, PictOpOver, setAlphaPict, alphaMask, picture, 0, 0, 0, 0, 100 + runs%10, 100+runs%10, 32, 32);
  
   /*Mask-Upload using Shm*/
//    currTile = (currTile == SHM_MASKS-1) ? 0 : ++currTile;
//    if(currTile == 0){
//       XSync(display, 0);
//    }
//    
//    XShmPutImage(display, shmPixmaps[currTile], shmGCs[currTile], shmImages[currTile], 0, 0, 0, 0, 32, 32, 0);
//    shmImages[currTile]->data[blackit%(32*32)] = 255;
// 
//    XRenderComposite(display, PictOpOver, setAlphaPict, shmPictures[currTile], picture, 0, 0, 0, 0, 100 + runs%10, 100+runs%10, 32, 32);

}
blackit++;
fflush(stdout);

XSync(display, 0);
int etime = usec();
printf("Msecs ellapsed: %d\n", ((etime-stime)/1000));fflush(stdout);	

				break;
			case DestroyNotify:
				return 0;
		}
	}
	
}
	return 0;
}