k_eglGetDisplayCopy.c

#include <EGL/egl.h>
#include <EGL/eglext_brcm.h>
#include <GLES2/gl2.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <sys/time.h>
#include <math.h>
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
/*  This file is part of X11EGLRPI
Copyright (C)2014 Mohamed MEDIOUNI

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

*/

#ifdef X11EGLRPI_EXPERIMENTAL_DLSYM
static int (*real_eglGetDisplay)(NativeDisplayType) = NULL;
static EGLSurface (*real_eglCreateWindowSurface)(EGLDisplay egldisplay, EGLConfig config, NativeWindowType native_window, EGLint const * attrib_list) = NULL;
static EGLBoolean (*real_eglSwapBuffers)(EGLDisplay edisplay, EGLSurface egsurface) = NULL;
#endif
static int x11_enabled = 0;
Window* root;
Window* window;
EGLDisplay *edisplay;
int width, height,depth;
Display* display;
EGLSurface egl_surface;
XWindowAttributes *window_attributes_return;
EGLDisplay eglGetDisplay(NativeDisplayType native_display) {
#ifdef X11EGLRPI_EXPERIMENTAL_DLSYM
	real_eglGetDisplay = dlsym(RTLD_NEXT, "eglGetDisplay");
	real_eglCreateWindowSurface = dlsym(RTLD_NEXT,"eglCreateWindowSurface");
	real_eglSwapBuffers= dlsym(RTLD_NEXT,"eglSwapBuffers");
#endif
	if ( native_display == EGL_DEFAULT_DISPLAY) {
		x11_enabled=0;
		return real_eglGetDisplay(native_display);
	}
	x11_enabled=1;
	puts("Getting an X11 EGL Display.");
	bcm_host_init();
	display = (Display*)native_display;
	root = DefaultRootWindow(display);
	edisplay = real_eglGetDisplay(EGL_DEFAULT_DISPLAY);
	return edisplay;
}
EGLSurface eglCreateWindowSurface(EGLDisplay egldisplay, EGLConfig config, NativeWindowType native_window, EGLint const * attrib_list) {
	if (x11_enabled == 0) {
		return real_eglCreateWindowSurface(egldisplay,config,native_window,attrib_list);
	}
	window = (Window*) native_window;
	puts("Getting window information...");
	XWindowAttributes window_attributes;
	XGetWindowAttributes(display,window,&window_attributes);
	printf("Window Location: %i,%i \n Window Dimensions %i x %i \n Bit depth : %i \n",window_attributes.x,window_attributes.y,window_attributes.width,window_attributes.height,window_attributes.depth);
	 width=window_attributes.width ;
	 height=window_attributes.height;
	 depth=window_attributes.depth;
	EGLint attr[] = { // some attributes to set up our egl-interface
                EGL_RED_SIZE, 8,
                EGL_GREEN_SIZE, 8,
                EGL_BLUE_SIZE, 8,
                EGL_ALPHA_SIZE, 8,
                EGL_SURFACE_TYPE,
                EGL_PIXMAP_BIT | EGL_OPENGL_ES2_BIT,
                EGL_NONE
        };

        EGLConfig ecfg;
        EGLint num_config;
        if (!eglChooseConfig(edisplay, attr, &ecfg, 1, &num_config)) {
                fprintf(stderr, "Failed to choose config (eglError: %s)\n");
                return EGL_NO_SURFACE;
        }
	EGLint pixel_format = EGL_PIXEL_FORMAT_ARGB_8888_BRCM;
        EGLint rt;
        eglGetConfigAttrib(edisplay, ecfg, EGL_RENDERABLE_TYPE, &rt);

        if (rt & EGL_OPENGL_ES_BIT) {
                pixel_format |= EGL_PIXEL_FORMAT_RENDER_GLES_BRCM;
                pixel_format |= EGL_PIXEL_FORMAT_GLES_TEXTURE_BRCM;
        }
        if (rt & EGL_OPENGL_ES2_BIT) {
                pixel_format |= EGL_PIXEL_FORMAT_RENDER_GLES2_BRCM;
                pixel_format |= EGL_PIXEL_FORMAT_GLES2_TEXTURE_BRCM;
        }
        if (rt & EGL_OPENVG_BIT) {
                pixel_format |= EGL_PIXEL_FORMAT_RENDER_VG_BRCM;
                pixel_format |= EGL_PIXEL_FORMAT_VG_IMAGE_BRCM;
        }
        if (rt & EGL_OPENGL_BIT) {
                pixel_format |= EGL_PIXEL_FORMAT_RENDER_GL_BRCM;
        }
	EGLint pixmap[5];
        pixmap[0] = 0;
        pixmap[1] = 0;
        pixmap[2] = width;
        pixmap[3] = height;
        pixmap[4] = pixel_format;
	eglCreateGlobalImageBRCM(width, height, pixmap[4], 0, width*4, pixmap);
	egl_surface = eglCreatePixmapSurface(edisplay, ecfg, pixmap, 0);
	puts("EGL Surface Created");
	EGLint ctxattr[] = {
                EGL_CONTEXT_CLIENT_VERSION, 2,
                EGL_NONE
        };
	EGLContext context = eglCreateContext ( edisplay, ecfg, EGL_NO_CONTEXT, ctxattr );
	real_eglMakeCurrent(edisplay, egl_surface, egl_surface, context);
	return egl_surface;
}
EGLBoolean eglSwapBuffers(EGLDisplay edisplay, EGLSurface egsurface) {
	 if (x11_enabled == 0) {
		return real_eglSwapBuffers(edisplay,egsurface);
	 }
	 unsigned int *buffer = (unsigned int *)malloc(height * width * 4);
         glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
	 static GC gc;
	 static int status =0;
	 static XImage *image =0;
         static Pixmap pixmap;
	 static XGCValues gcvalues;
	 if (status == 0 ) {	
	 	gc = XCreateGC(display, window,0,&gcvalues);
		image = XGetImage(display, window, 0, 0, width, height, AllPlanes, ZPixmap);
		status = 1;
	 }
	 XImage *img = XCreateImage(display,CopyFromParent,depth,ZPixmap,0,buffer,width, height, 32, 0);
	 XPutImage(display, window, gc, img, 0, 0, 0, 0, width, height);
	 free(buffer);
	 return EGL_TRUE;
}
EGLBoolean eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context) {
	real_eglMakeCurrent(display,draw,read,context);
	return EGL_TRUE;
}