static EGLNativeWindowType nullws_CreateWindow(EGLNativeWindowType win, struct _EGLDisplay *display)
{
if (win == 0)
{
return android_createDisplaySurface();
}
else
return win;
}
NativeWindowAndroidLinux::NativeWindowAndroidLinux(const EGLNativeDisplayType, const RenderConfig& renderConfig, const EGLDisplay&, const EGLConfig&)
{
if( renderConfig.GetWindowMode() != RenderWindowMode::Fullscreen || renderConfig.GetTargetRectangle().Width() != 0 || renderConfig.GetTargetRectangle().Height() != 0)
{
std::cout << "WARNING: NativeWindowAndroidLinux only support full-screen mode" << std::endl;
std::cout.flush();
}
mhWindow = android_createDisplaySurface();
}
int init(int argc, char** argv) {
for(int i = 0; i < argc; i++) {
char* p = argv[i];
if (strcmp(p, "-noevents") == 0) {
printf("-noevents: will not look for events.\n");
gNoEvents = true;
}
}
if (! gNoEvents) {
gpEventQueue = new EventQueue();
}
EGLNativeWindowType window = android_createDisplaySurface();
gDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
EGLint majorVersion;
EGLint minorVersion;
eglInitialize(gDisplay, &majorVersion, &minorVersion);
checkEGLError("eglInitialize");
EGLint configRequest[] = {
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT|EGL_WINDOW_BIT,
EGL_DEPTH_SIZE, 16,
EGL_NONE
};
EGLConfig config;
android::EGLUtils::selectConfigForNativeWindow(gDisplay, configRequest, window, &config);
gSurface = eglCreateWindowSurface(gDisplay, config, window, NULL);
eglQuerySurface(gDisplay, gSurface, EGL_WIDTH, &gDisplayWidth);
eglQuerySurface(gDisplay, gSurface, EGL_HEIGHT, &gDisplayHeight);
fprintf(stderr, "display width = %d, height = %d\n", gDisplayWidth,
gDisplayHeight);
gContext = eglCreateContext(gDisplay, config, NULL, NULL);
checkEGLError("eglCreateContext");
eglMakeCurrent(gDisplay, gSurface, gSurface, gContext);
checkEGLError("eglMakeCurrent");
printf("vendor : %s\n", glGetString(GL_VENDOR));
printf("renderer : %s\n", glGetString(GL_RENDERER));
printf("version : %s\n", glGetString(GL_VERSION));
printf("extensions: %s\n", glGetString(GL_EXTENSIONS));
return 0;
}
int GLES_Init(int * w, int *h)
{
EGLint majorVersion, minorVersion;
int numConfigs;
// Display
eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
printf("GLES: Display %p\n", eglDisplay);
// Window surface that covers the entire screen, from libui.
displayWindow = android_createDisplaySurface();
* w = displayWindow->width;
* h = displayWindow->height;
printf("GLES: Window specs: %d*%d format=%d\n", *w, *h , displayWindow->format);
// Init
eglInitialize(eglDisplay, &majorVersion, &minorVersion);
printf("GLES: Version: %d.%d\n",majorVersion,minorVersion);
// Choose config
if (!eglChooseConfig(eglDisplay, config16bpp, &eglConfig, 1, &numConfigs))
{
printf("eglChooseConfig failed\n");
if (eglContext==0) printf("Error code: %x\n", eglGetError());
}
// create context
eglContext = eglCreateContext(eglDisplay, eglConfig, EGL_NO_CONTEXT, NULL);
if (eglContext==0) {
//printf("Error code: %x\n", eglGetError());
exit(-1);
}
//printf("GLES: GL context: %x\n", eglContext);
// create surface
eglSurface = eglCreateWindowSurface(eglDisplay, eglConfig, displayWindow, NULL);
if (eglSurface==0) {
printf("Error code: %x\n", eglGetError());
exit (-1);
}
printf("GLES: GL surface: %x\n", eglSurface);
// make current
eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext);
}
int init_gl_surface(void)
{
EGLint numConfigs = 1;
EGLConfig myConfig = {0};
EGLint attrib[] =
{
EGL_DEPTH_SIZE, 16,
EGL_NONE
};
if ( (eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY)) == EGL_NO_DISPLAY )
{
printf("eglGetDisplay failed\n");
return 0;
}
if ( eglInitialize(eglDisplay, NULL, NULL) != EGL_TRUE )
{
printf("eglInitialize failed\n");
return 0;
}
if ( eglChooseConfig(eglDisplay, attrib, &myConfig, 1, &numConfigs) != EGL_TRUE )
{
printf("eglChooseConfig failed\n");
return 0;
}
if ( (eglSurface = eglCreateWindowSurface(eglDisplay, myConfig,
android_createDisplaySurface(), 0)) == EGL_NO_SURFACE )
{
printf("eglCreateWindowSurface failed\n");
return 0;
}
if ( (eglContext = eglCreateContext(eglDisplay, myConfig, 0, 0)) == EGL_NO_CONTEXT )
{
printf("eglCreateContext failed\n");
return 0;
}
if ( eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext) != EGL_TRUE )
{
printf("eglMakeCurrent failed\n");
return 0;
}
return 1;
}
int main(void)
{
EGLint major, minor, eglCfgCount, eglCfgVisualId, width, height;
const IMG_gralloc_module_public_t *module;
buffer_handle_t srcBuffer, destBuffer;
EGLImageKHR eglSrcImage, eglDestImage;
EGLConfig eglConfig, eglFBConfig;
GLuint fboName, textureNames[2];
EGLNativeWindowType eglWindow;
EGLSurface eglWindowSurface;
alloc_device_t *device;
EGLContext eglContext;
EGLDisplay eglDisplay;
int err = 1, stride;
GLenum glError;
ANativeWindowBuffer sSrcBuffer =
{
.common.magic = ANDROID_NATIVE_BUFFER_MAGIC,
.common.version = sizeof(ANativeWindowBuffer),
.common.incRef = incRefNop,
.common.decRef = decRefNop,
.width = SRC_WIDTH,
.height = SRC_HEIGHT,
.stride = SRC_STRIDE,
.usage = GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE,
};
ANativeWindowBuffer sDestBuffer =
{
.common.magic = ANDROID_NATIVE_BUFFER_MAGIC,
.common.version = sizeof(ANativeWindowBuffer),
.common.incRef = incRefNop,
.common.decRef = decRefNop,
.width = DEST_WIDTH,
.height = DEST_HEIGHT,
.stride = DEST_STRIDE,
.format = DEST_FORMAT,
.usage = GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE,
};
EGLint eglCfgAttribs[] =
{
EGL_RED_SIZE, 5,
EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5,
EGL_ALPHA_SIZE, 0,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
#ifdef EGL_ANDROID_recordable
EGL_RECORDABLE_ANDROID, EGL_TRUE,
#endif
EGL_NONE,
};
const float srcVertexArray[2 * 4] = {
0.0f, 1.0f,
0.0f, 0.0f,
1.0f, 1.0f,
1.0f, 0.0f,
};
const float texCoordArray[2 * 4] = {
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f,
1.0f, 1.0f,
};
const float destVertexArray[2 * 4] = {
-1.0f, 0.0f,
-1.0f, -1.0f,
0.0f, 0.0f,
0.0f, -1.0f,
};
eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if(eglDisplay == EGL_NO_DISPLAY)
{
printf("eglGetDisplay failed\n");
goto err_out;
}
if(!eglInitialize(eglDisplay, &major, &minor))
{
printf("eglInitialize failed (err=0x%x)\n", eglGetError());
goto err_out;
}
if(!eglChooseConfig(eglDisplay, eglCfgAttribs,
&eglConfig, 1, &eglCfgCount))
{
printf("eglChooseConfig failed (err=0x%x)\n", eglGetError());
goto err_terminate;
}
if(!eglCfgCount)
{
printf("eglChooseConfig found no suitable configs\n");
goto err_terminate;
}
if(!eglGetConfigAttrib(eglDisplay, eglConfig,
EGL_NATIVE_VISUAL_ID, &eglCfgVisualId))
{
printf("eglGetConfigAttrib failed (err=0x%x)\n", eglGetError());
goto err_terminate;
}
sSrcBuffer.format = eglCfgVisualId;
/* Handle FB rendering ***************************************************/
eglWindow = android_createDisplaySurface();
if(!eglWindow)
{
printf("android_createDisplaySurface returned NULL\n");
goto err_terminate;
}
eglWindow->common.incRef(&eglWindow->common);
eglFBConfig = findMatchingWindowConfig(eglDisplay, EGL_OPENGL_ES_BIT, eglWindow);
/* FIXME: findMatchingWindowConfig returns no error code */
eglContext = eglCreateContext(eglDisplay, eglFBConfig, EGL_NO_CONTEXT, NULL);
if(eglContext == EGL_NO_CONTEXT)
{
printf("eglCreateContext failed (err=0x%x)\n", eglGetError());
goto err_window_decref;
}
eglWindowSurface = eglCreateWindowSurface(eglDisplay, eglFBConfig, eglWindow, NULL);
if(eglWindowSurface == EGL_NO_SURFACE)
{
printf("eglCreateWindowSurface failed (err=0x%x)\n", eglGetError());
goto err_destroy_context;
}
if(!eglQuerySurface(eglDisplay, eglWindowSurface, EGL_WIDTH, &width))
{
printf("eglQuerySurface #1 failed (err=0x%x)\n", eglGetError());
goto err_destroy_context;
}
if(!eglQuerySurface(eglDisplay, eglWindowSurface, EGL_HEIGHT, &height))
{
printf("eglQuerySurface #2 failed (err=0x%x)\n", eglGetError());
goto err_destroy_context;
}
if(!eglMakeCurrent(eglDisplay, eglWindowSurface, eglWindowSurface, eglContext))
{
printf("eglMakeCurrent failed (err=0x%x)\n", eglGetError());
goto err_destroy_surface;
}
/* Allocate some compatible buffers with gralloc *************************/
err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID,
(const hw_module_t **)&module);
if(err)
{
printf("hw_get_module failed (err=%d)\n", err);
goto err_make_non_current;
}
err = module->base.common.methods->open((const hw_module_t *)module,
GRALLOC_HARDWARE_GPU0,
(hw_device_t **)&device);
if(err)
{
printf("module->common.methods->open() failed (err=%d)\n", err);
goto err_make_non_current;
}
err = device->alloc(device, SRC_WIDTH, SRC_HEIGHT, eglCfgVisualId,
GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE,
&srcBuffer, &stride);
if(err)
{
printf("device->alloc() failed (err=%d)\n", err);
goto err_close;
}
err = device->alloc(device, DEST_WIDTH, DEST_HEIGHT, DEST_FORMAT,
GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE,
&destBuffer, &stride);
if(err)
{
printf("device->alloc() failed (err=%d)\n", err);
goto err_free_src;
}
err = module->base.registerBuffer(&module->base, srcBuffer);
if(err)
{
printf("module->registerBuffer() failed (err=%d)\n", err);
goto err_free_dest;
}
err = module->base.registerBuffer(&module->base, destBuffer);
if(err)
{
printf("module->registerBuffer() failed (err=%d)\n", err);
goto err_unregister_src;
}
sSrcBuffer.handle = srcBuffer;
sDestBuffer.handle = destBuffer;
/* Make some EGLImageKHRs out of them ************************************/
eglSrcImage = eglCreateImageKHR(eglDisplay, EGL_NO_CONTEXT,
EGL_NATIVE_BUFFER_ANDROID,
(EGLClientBuffer)&sSrcBuffer, 0);
if(eglSrcImage == EGL_NO_IMAGE_KHR)
{
printf("eglCreateImageKHR #1 failed (err=0x%x)\n", eglGetError());
goto err_unregister_dest;
}
eglDestImage = eglCreateImageKHR(eglDisplay, EGL_NO_CONTEXT,
EGL_NATIVE_BUFFER_ANDROID,
(EGLClientBuffer)&sDestBuffer, 0);
if(eglDestImage == EGL_NO_IMAGE_KHR)
{
printf("eglCreateImageKHR #2 failed (err=0x%x)\n", eglGetError());
goto err_destroy_src_image;
}
/* Create funny textures *************************************************/
glGenTextures(2, textureNames);
glError = glGetError();
if(glError != GL_NO_ERROR)
{
printf("glGenTextures generated error 0x%x\n", glError);
goto err_destroy_dest_image;
}
glBindTexture(GL_TEXTURE_2D, textureNames[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, eglSrcImage);
glError = glGetError();
if(glError != GL_NO_ERROR)
{
printf("glEGLImageTargetTexture2DOES generated error 0x%x\n", glError);
goto err_delete_textures;
}
glBindTexture(GL_TEXTURE_EXTERNAL_OES, textureNames[1]);
glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, eglDestImage);
glError = glGetError();
if(glError != GL_NO_ERROR)
{
printf("glEGLImageTargetTexture2DOES generated error 0x%x\n", glError);
goto err_delete_textures;
}
/* Create FBO ************************************************************/
glGenFramebuffersOES(1, &fboName);
glError = glGetError();
if(glError != GL_NO_ERROR)
{
printf("glGenFrameBuffersOES generated error 0x%x\n", glError);
goto err_delete_textures;
}
glBindFramebufferOES(GL_FRAMEBUFFER_OES, fboName);
glError = glGetError();
if(glError != GL_NO_ERROR)
{
printf("glBindFramebufferOES generated error 0x%x\n", glError);
goto err_delete_framebuffer;
}
glBindTexture(GL_TEXTURE_2D, textureNames[0]);
glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES,
GL_TEXTURE_2D, textureNames[0], 0);
glError = glGetError();
if(glError != GL_NO_ERROR)
{
printf("glFramebufferTexture2DOES generated error 0x%x\n", glError);
goto err_delete_framebuffer;
}
/*************************************************************************/
glError = glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
if(glError != GL_FRAMEBUFFER_COMPLETE_OES)
{
printf("glCheckFramebufferStatus generated error 0x%x\n", glError);
goto err_delete_framebuffer;
}
/* Draw some stuff */
{
const float vertexArray[2 * 4] = {
-1.0f, 1.0f,
-1.0f, -1.0f,
1.0f, 1.0f,
1.0f, -1.0f,
};
const float colorArray[4 * 4] = {
1.0f, 0.0f, 0.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f,
1.0f, 0.0f, 1.0f, 1.0f,
};
char dummy[4];
glViewport(0, 0, SRC_WIDTH, SRC_HEIGHT);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, vertexArray);
glColorPointer(4, GL_FLOAT, 0, colorArray);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, dummy);
}
/* RGB -> YUV blit */
err = module->Blit2(module, srcBuffer, destBuffer,
SRC_WIDTH, SRC_HEIGHT, 0, 0);
if(err)
{
printf("module->Blit2() failed (err=%d)\n", err);
goto err_delete_framebuffer;
}
/* Present both to screen (should appear identical) */
glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
glViewport(0, 0, width, height);
glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
glEnable(GL_TEXTURE_EXTERNAL_OES);
glBindTexture(GL_TEXTURE_EXTERNAL_OES, textureNames[1]);
glVertexPointer(2, GL_FLOAT, 0, destVertexArray);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDisable(GL_TEXTURE_EXTERNAL_OES);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, textureNames[0]);
glVertexPointer(2, GL_FLOAT, 0, srcVertexArray);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDisable(GL_TEXTURE_2D);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
eglSwapBuffers(eglDisplay, eglWindowSurface);
sleep(1);
err_delete_framebuffer:
glDeleteFramebuffersOES(1, &fboName);
err_delete_textures:
glDeleteTextures(2, textureNames);
err_destroy_dest_image:
eglDestroyImageKHR(eglDisplay, eglDestImage);
err_destroy_src_image:
eglDestroyImageKHR(eglDisplay, eglSrcImage);
err_unregister_dest:
err = module->base.unregisterBuffer(&module->base, destBuffer);
if(err)
printf("module->unregisterBuffer() failed (err=%d)\n", err);
err_unregister_src:
err = module->base.unregisterBuffer(&module->base, srcBuffer);
if(err)
printf("module->unregisterBuffer() failed (err=%d)\n", err);
err_free_dest:
err = device->free(device, destBuffer);
if(err)
printf("device->free() failed (err=%d)\n", err);
err_free_src:
err = device->free(device, srcBuffer);
if(err)
printf("device->free() failed (err=%d)\n", err);
err_close:
err = device->common.close((hw_device_t *)device);
if(err)
printf("hal->close() failed (err=%d)\n", err);
err_make_non_current:
eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
err_destroy_surface:
eglDestroySurface(eglDisplay, eglWindowSurface);
err_destroy_context:
eglDestroyContext(eglDisplay, eglContext);
err_window_decref:
eglWindow->common.decRef(&eglWindow->common);
err_terminate:
eglTerminate(eglDisplay);
err_out:
return err;
}
