/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "libOpenglRender/render_api.h"
#include "IOStream.h"
#include "FrameBuffer.h"
#include "RenderServer.h"
#include "osProcess.h"
#include "TimeUtils.h"
#include "TcpStream.h"
#ifdef _WIN32
#include "Win32PipeStream.h"
#else
#include "UnixStream.h"
#endif
#include "EGLDispatch.h"
#include "GLDispatch.h"
#include "GL2Dispatch.h"
static osUtils::childProcess *s_renderProc = NULL;
static RenderServer *s_renderThread = NULL;
static char s_renderAddr[256];
static IOStream *createRenderThread(int p_stream_buffer_size,
unsigned int clientFlags);
//
// For now run the renderer as a thread inside the calling
// process instead as running it in a separate process for all
// platforms.
// at the future we want it to run as a seperate process except for
// Mac OS X since it is imposibble on this platform to make one process
// render to a window created by another process.
//
//#ifdef __APPLE__
#define RENDER_API_USE_THREAD
//#endif
int initLibrary(void)
{
//
// Load EGL Plugin
//
if (!init_egl_dispatch()) {
// Failed to load EGL
printf("Failed to init_egl_dispatch\n");
return false;
}
//
// Load GLES Plugin
//
if (!init_gl_dispatch()) {
// Failed to load GLES
ERR("Failed to init_gl_dispatch\n");
return false;
}
/* failure to init the GLES2 dispatch table is not fatal */
init_gl2_dispatch();
return true;
}
int initOpenGLRenderer(int width, int height, char* addr, size_t addrLen)
{
//
// Fail if renderer is already initialized
//
if (s_renderProc || s_renderThread) {
return false;
}
#ifdef RENDER_API_USE_THREAD // should be defined for mac
//
// initialize the renderer and listen to connections
// on a thread in the current process.
//
bool inited = FrameBuffer::initialize(width, height);
if (!inited) {
return false;
}
s_renderThread = RenderServer::create(addr, addrLen);
if (!s_renderThread) {
return false;
}
strncpy(s_renderAddr, addr, sizeof(s_renderAddr));
s_renderThread->start();
#else
if (onPost) {
// onPost callback not supported with separate renderer process.
//
// If we ever revive separate process support, we could make the choice
// between thread and process at runtime instead of compile time, and
// choose the thread path if an onPost callback is requested. Or, the
// callback could be supported with a separate process using shmem or
// other IPC mechanism.
return false;
}
//
// Launch emulator_renderer
//
char cmdLine[128];
snprintf(cmdLine, 128, "emulator_renderer -windowid %d -port %d -x %d -y %d -width %d -height %d",
(int)window, portNum, x, y, width, height);
s_renderProc = osUtils::childProcess::create(cmdLine, NULL);
if (!s_renderProc) {
return false;
}
//
// try to connect to the renderer in order to check it
// was successfully initialized.
//
int nTrys = 0;
IOStream *dummy = NULL;
do {
++nTrys;
//
// Wait a bit to make the renderer process a chance to be
// initialized.
// On Windows we need during this time to handle windows
// events since the renderer generates a subwindow of this
// process's window, we need to be responsive for windows
// during this time to let the renderer generates this subwindow.
//
#ifndef _WIN32
TimeSleepMS(300);
#else
long long t0 = GetCurrentTimeMS();
while( (GetCurrentTimeMS() - t0) < 300 ) {
MSG msg;
int n = 0;
while( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
{
n++;
TranslateMessage( &msg );
DispatchMessage( &msg );
}
if (n == 0) TimeSleepMS(10);
}
#endif
dummy = createRenderThread(8, 0);
if (!dummy) {
// stop if the process is no longer running
if (!osUtils::isProcessRunning(s_renderProc->getPID())) {
break;
}
}
} while(!dummy && nTrys < 10); // give up after 3 seconds, XXX: ???
if (!dummy) {
//
// Failed - make sure the process is killed
//
osUtils::KillProcess(s_renderProc->getPID(), true);
delete s_renderProc;
s_renderProc = NULL;
return false;
}
// destroy the dummy connection
delete dummy;
#endif
return true;
}
void setPostCallback(OnPostFn onPost, void* onPostContext)
{
#ifdef RENDER_API_USE_THREAD // should be defined for mac
FrameBuffer* fb = FrameBuffer::getFB();
if (fb) {
fb->setPostCallback(onPost, onPostContext);
}
#else
if (onPost) {
// onPost callback not supported with separate renderer process.
//
// If we ever revive separate process support, we could make the choice
// between thread and process at runtime instead of compile time, and
// choose the thread path if an onPost callback is requested. Or, the
// callback could be supported with a separate process using shmem or
// other IPC mechanism.
return false;
}
#endif
}
void getHardwareStrings(const char** vendor, const char** renderer, const char** version)
{
FrameBuffer* fb = FrameBuffer::getFB();
if (fb) {
fb->getGLStrings(vendor, renderer, version);
} else {
*vendor = *renderer = *version = NULL;
}
}
int stopOpenGLRenderer(void)
{
bool ret = false;
// open a dummy connection to the renderer to make it
// realize the exit request.
// (send the exit request in clientFlags)
IOStream *dummy = createRenderThread(8, IOSTREAM_CLIENT_EXIT_SERVER);
if (!dummy) return false;
if (s_renderProc) {
//
// wait for the process to exit
//
int exitStatus;
ret = s_renderProc->wait(&exitStatus);
delete s_renderProc;
s_renderProc = NULL;
}
else if (s_renderThread) {
// wait for the thread to exit
int status;
ret = s_renderThread->wait(&status);
delete s_renderThread;
s_renderThread = NULL;
}
return ret;
}
int createOpenGLSubwindow(FBNativeWindowType window,
int x, int y, int width, int height, float zRot)
{
if (s_renderThread) {
return FrameBuffer::setupSubWindow(window,x,y,width,height, zRot);
}
else {
//
// XXX: should be implemented by sending the renderer process
// a request
ERR("%s not implemented for separate renderer process !!!\n",
__FUNCTION__);
}
return false;
}
int destroyOpenGLSubwindow(void)
{
if (s_renderThread) {
return FrameBuffer::removeSubWindow();
}
else {
//
// XXX: should be implemented by sending the renderer process
// a request
ERR("%s not implemented for separate renderer process !!!\n",
__FUNCTION__);
return false;
}
}
void setOpenGLDisplayRotation(float zRot)
{
if (s_renderThread) {
FrameBuffer *fb = FrameBuffer::getFB();
if (fb) {
fb->setDisplayRotation(zRot);
}
}
else {
//
// XXX: should be implemented by sending the renderer process
// a request
ERR("%s not implemented for separate renderer process !!!\n",
__FUNCTION__);
}
}
void repaintOpenGLDisplay(void)
{
if (s_renderThread) {
FrameBuffer *fb = FrameBuffer::getFB();
if (fb) {
fb->repost();
}
}
else {
//
// XXX: should be implemented by sending the renderer process
// a request
ERR("%s not implemented for separate renderer process !!!\n",
__FUNCTION__);
}
}
/* NOTE: For now, always use TCP mode by default, until the emulator
* has been updated to support Unix and Win32 pipes
*/
#define DEFAULT_STREAM_MODE STREAM_MODE_TCP
int gRendererStreamMode = DEFAULT_STREAM_MODE;
IOStream *createRenderThread(int p_stream_buffer_size, unsigned int clientFlags)
{
SocketStream* stream = NULL;
if (gRendererStreamMode == STREAM_MODE_TCP) {
stream = new TcpStream(p_stream_buffer_size);
} else {
#ifdef _WIN32
stream = new Win32PipeStream(p_stream_buffer_size);
#else /* !_WIN32 */
stream = new UnixStream(p_stream_buffer_size);
#endif
}
if (!stream) {
ERR("createRenderThread failed to create stream\n");
return NULL;
}
if (stream->connect(s_renderAddr) < 0) {
ERR("createRenderThread failed to connect\n");
delete stream;
return NULL;
}
//
// send clientFlags to the renderer
//
unsigned int *pClientFlags =
(unsigned int *)stream->allocBuffer(sizeof(unsigned int));
*pClientFlags = clientFlags;
stream->commitBuffer(sizeof(unsigned int));
return stream;
}
int
setStreamMode(int mode)
{
switch (mode) {
case STREAM_MODE_DEFAULT:
mode = DEFAULT_STREAM_MODE;
break;
case STREAM_MODE_TCP:
break;
#ifndef _WIN32
case STREAM_MODE_UNIX:
break;
#else /* _WIN32 */
case STREAM_MODE_PIPE:
break;
#endif /* _WIN32 */
default:
// Invalid stream mode
return false;
}
gRendererStreamMode = mode;
return true;
}