EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface eglSurface) { VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); if (eglSurface == EGL_NO_SURFACE) setErrorReturn(EGL_BAD_SURFACE, EGL_FALSE); DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); egl_surface_t* d = static_cast<egl_surface_t*>(eglSurface); if (d->dpy != dpy) setErrorReturn(EGL_BAD_DISPLAY, EGL_FALSE); // post the surface d->swapBuffers(); hostCon->flush(); return EGL_TRUE; }
EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval) { VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); EGLContext_t* ctx = getEGLThreadInfo()->currentContext; if (!ctx) { setErrorReturn(EGL_BAD_CONTEXT, EGL_FALSE); } if (!ctx->draw) { setErrorReturn(EGL_BAD_SURFACE, EGL_FALSE); } egl_surface_t* draw(static_cast<egl_surface_t*>(ctx->draw)); draw->setSwapInterval(interval); rcEnc->rcFBSetSwapInterval(rcEnc, interval); //TODO: implement on the host return EGL_TRUE; }
EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value) { if (sync != FENCE_SYNC_HANDLE) { setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE); } switch (attribute) { case EGL_SYNC_TYPE_KHR: *value = EGL_SYNC_FENCE_KHR; return EGL_TRUE; case EGL_SYNC_STATUS_KHR: *value = EGL_SIGNALED_KHR; return EGL_TRUE; case EGL_SYNC_CONDITION_KHR: *value = EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR; return EGL_TRUE; default: setErrorReturn(EGL_BAD_ATTRIBUTE, EGL_FALSE); } }
EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list) { VALIDATE_DISPLAY_INIT(dpy, EGL_NO_CONTEXT); VALIDATE_CONFIG(config, EGL_NO_CONTEXT); EGLint version = 1; //default while (attrib_list && attrib_list[0]) { if (attrib_list[0] == EGL_CONTEXT_CLIENT_VERSION) version = attrib_list[1]; attrib_list+=2; } uint32_t rcShareCtx = 0; EGLContext_t * shareCtx = NULL; if (share_context) { shareCtx = static_cast<EGLContext_t*>(share_context); rcShareCtx = shareCtx->rcContext; if (shareCtx->dpy != dpy) setErrorReturn(EGL_BAD_MATCH, EGL_NO_CONTEXT); } DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_NO_CONTEXT); uint32_t rcContext = rcEnc->rcCreateContext(rcEnc, (uint32_t)config, rcShareCtx, version); if (!rcContext) { ALOGE("rcCreateContext returned 0"); setErrorReturn(EGL_BAD_ALLOC, EGL_NO_CONTEXT); } EGLContext_t * context = new EGLContext_t(dpy, config, shareCtx); if (!context) setErrorReturn(EGL_BAD_ALLOC, EGL_NO_CONTEXT); context->version = version; context->rcContext = rcContext; return context; }
EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list) { VALIDATE_DISPLAY_INIT(dpy, EGL_NO_IMAGE_KHR); if (ctx != EGL_NO_CONTEXT) { setErrorReturn(EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR); } if (target != EGL_NATIVE_BUFFER_ANDROID) { setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR); } android_native_buffer_t* native_buffer = (android_native_buffer_t*)buffer; if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC) setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR); if (native_buffer->common.version != sizeof(android_native_buffer_t)) setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR); cb_handle_t *cb = (cb_handle_t *)(native_buffer->handle); switch (cb->format) { case HAL_PIXEL_FORMAT_RGBA_8888: case HAL_PIXEL_FORMAT_RGBX_8888: case HAL_PIXEL_FORMAT_RGB_888: case HAL_PIXEL_FORMAT_RGB_565: case HAL_PIXEL_FORMAT_BGRA_8888: case HAL_PIXEL_FORMAT_RGBA_5551: case HAL_PIXEL_FORMAT_RGBA_4444: break; default: setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR); } native_buffer->common.incRef(&native_buffer->common); return (EGLImageKHR)native_buffer; }
EGLSurface eglGetCurrentSurface(EGLint readdraw) { EGLContext_t * context = getEGLThreadInfo()->currentContext; if (!context) return EGL_NO_SURFACE; //not an error switch (readdraw) { case EGL_READ: return context->read; case EGL_DRAW: return context->draw; default: setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_SURFACE); } }
EGLBoolean egl_window_surface_t::swapBuffers() { DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); rcEnc->rcFlushWindowColorBuffer(rcEnc, rcSurface); nativeWindow->queueBuffer_DEPRECATED(nativeWindow, buffer); if (nativeWindow->dequeueBuffer_DEPRECATED(nativeWindow, &buffer)) { buffer = NULL; setErrorReturn(EGL_BAD_ALLOC, EGL_FALSE); } rcEnc->rcSetWindowColorBuffer(rcEnc, rcSurface, ((cb_handle_t *)(buffer->handle))->hostHandle); return EGL_TRUE; }
EGLBoolean egl_window_surface_t::init() { if (nativeWindow->dequeueBuffer_DEPRECATED(nativeWindow, &buffer) != NO_ERROR) { setErrorReturn(EGL_BAD_ALLOC, EGL_FALSE); } DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); rcSurface = rcEnc->rcCreateWindowSurface(rcEnc, (uint32_t)config, getWidth(), getHeight()); if (!rcSurface) { ALOGE("rcCreateWindowSurface returned 0"); return EGL_FALSE; } rcEnc->rcSetWindowColorBuffer(rcEnc, rcSurface, ((cb_handle_t*)(buffer->handle))->hostHandle); return EGL_TRUE; }
EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) { VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE); VALIDATE_SURFACE_RETURN(draw, EGL_FALSE); VALIDATE_SURFACE_RETURN(read, EGL_FALSE); if ((read == EGL_NO_SURFACE && draw == EGL_NO_SURFACE) && (ctx != EGL_NO_CONTEXT)) setErrorReturn(EGL_BAD_MATCH, EGL_FALSE); if ((read != EGL_NO_SURFACE || draw != EGL_NO_SURFACE) && (ctx == EGL_NO_CONTEXT)) setErrorReturn(EGL_BAD_MATCH, EGL_FALSE); EGLContext_t * context = static_cast<EGLContext_t*>(ctx); uint32_t ctxHandle = (context) ? context->rcContext : 0; egl_surface_t * drawSurf = static_cast<egl_surface_t *>(draw); uint32_t drawHandle = (drawSurf) ? drawSurf->getRcSurface() : 0; egl_surface_t * readSurf = static_cast<egl_surface_t *>(read); uint32_t readHandle = (readSurf) ? readSurf->getRcSurface() : 0; // // Nothing to do if no binding change has made // EGLThreadInfo *tInfo = getEGLThreadInfo(); if (tInfo->currentContext == context && (context == NULL || (context && context->draw == draw && context->read == read))) { return EGL_TRUE; } if (context && (context->flags & EGLContext_t::IS_CURRENT) && (context != tInfo->currentContext)) { //context is current to another thread setErrorReturn(EGL_BAD_ACCESS, EGL_FALSE); } DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); if (rcEnc->rcMakeCurrent(rcEnc, ctxHandle, drawHandle, readHandle) == EGL_FALSE) { ALOGE("rcMakeCurrent returned EGL_FALSE"); setErrorReturn(EGL_BAD_CONTEXT, EGL_FALSE); } //Now make the local bind if (context) { context->draw = draw; context->read = read; context->flags |= EGLContext_t::IS_CURRENT; //set the client state if (context->version == 2) { hostCon->gl2Encoder()->setClientState(context->getClientState()); hostCon->gl2Encoder()->setSharedGroup(context->getSharedGroup()); } else { hostCon->glEncoder()->setClientState(context->getClientState()); hostCon->glEncoder()->setSharedGroup(context->getSharedGroup()); } } else { //release ClientState & SharedGroup if (tInfo->currentContext->version == 2) { hostCon->gl2Encoder()->setClientState(NULL); hostCon->gl2Encoder()->setSharedGroup(GLSharedGroupPtr(NULL)); } else { hostCon->glEncoder()->setClientState(NULL); hostCon->glEncoder()->setSharedGroup(GLSharedGroupPtr(NULL)); } } if (tInfo->currentContext) tInfo->currentContext->flags &= ~EGLContext_t::IS_CURRENT; //Now make current tInfo->currentContext = context; //Check maybe we need to init the encoder, if it's first eglMakeCurrent if (tInfo->currentContext) { if (tInfo->currentContext->version == 2) { if (!hostCon->gl2Encoder()->isInitialized()) { s_display.gles2_iface()->init(); hostCon->gl2Encoder()->setInitialized(); ClientAPIExts::initClientFuncs(s_display.gles2_iface(), 1); } } else { if (!hostCon->glEncoder()->isInitialized()) { s_display.gles_iface()->init(); hostCon->glEncoder()->setInitialized(); ClientAPIExts::initClientFuncs(s_display.gles_iface(), 0); } } } return EGL_TRUE; }
EGLBoolean eglBindAPI(EGLenum api) { if (api != EGL_OPENGL_ES_API) setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE); return EGL_TRUE; }
void setErrorCode(mpkgErrorCode value) { if (value != MPKG_OK) setErrorReturn(MPKG_RETURN_WAIT); errorCode = value; }
mpkgErrorReturn callError(mpkgErrorCode err, string details) { setErrorCode(err); errorDescription e; int ret=0; Dialog d(_("error"), "MOPSLinux package system"); vector<string> menuItems; for (unsigned int i=0; i<errorList.size(); i++) { if (errorList[i].code==err) { e=errorList[i]; break; } } switch(errorManagerMode) { case EMODE_CONSOLE: // Ugly console mode if (e.action.size()==1) // If we have no choice.. { if (e.action[0].ret==MPKG_RETURN_CONTINUE) { say("%s\n",e.text.c_str()); if (!details.empty()) say(_("Details: %s\n"),details.c_str()); } else { mError(e.text); if (!details.empty()) mError(_("Details: ") + details); } setErrorReturn(e.action[0].ret); break; } mError(e.text); eCLI_pickAction: mError(_("Choose an action:")); for (unsigned int x=0; x<e.action.size(); x++) { say("\t[%d] %s\n",x+1, e.action[x].text.c_str()); } cin>>ret; if (ret>0 && (unsigned int) ret<=e.action.size()) { // Return value OK, returning say(_("You decided to %s\n"), e.action[ret-1].text.c_str()); setErrorReturn(e.action[ret-1].ret); } else { say(_("Invalid input\n")); goto eCLI_pickAction; } break; case EMODE_DIALOG: if (!details.empty()) details = "\nDetails: " + details; // Call dialog event resolver for (unsigned int i=0; i<e.action.size(); i++) { menuItems.push_back(e.action[i].text); } if (e.action.size()==1) // If we have no choice.. { if (e.action[0].ret==MPKG_RETURN_CONTINUE) { d.setTitle("Information", "MOPSLinux package system"); d.execInfoBox(e.text + details); } else { mError(e.text); d.execMsgBox(e.text + details); } setErrorReturn(e.action[0].ret); break; } ret = d.execMenu(e.text, menuItems); if (ret>=0 && (unsigned int) ret<e.action.size()) { setErrorReturn(e.action[ret].ret); } else { mError("Aborted"); } break; case EMODE_QT: // Waiting for GUI error catcher (threaded) while ( getErrorReturn() == MPKG_RETURN_WAIT) { sleep(1); } break; default: mError("Unknown UI mode, aborting"); say("errorManagerMode is %d\n", errorManagerMode); if (consoleMode) mError("consoleMode: true"); else mError("consoleMode: false"); if (dialogMode) mError("dialogMode: true"); else mError("dialogMode: false"); abort(); } return getErrorReturn(); }