void WindowGrabber::createEglImages()
{
// Do nothing if either egl images are not supported, the screen context is not valid
// or the images are already created
if (!eglImageSupported() || !m_screenContextInitialized || eglImagesInitialized())
return;
glGenTextures(2, imgTextures);
glBindTexture(GL_TEXTURE_2D, imgTextures[0]);
img[0] = eglCreateImageKHR(eglGetDisplay(EGL_DEFAULT_DISPLAY), EGL_NO_CONTEXT,
EGL_NATIVE_PIXMAP_KHR,
m_screenPixmaps[0],
0);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, img[0]);
glBindTexture(GL_TEXTURE_2D, imgTextures[1]);
img[1] = eglCreateImageKHR(eglGetDisplay(EGL_DEFAULT_DISPLAY), EGL_NO_CONTEXT,
EGL_NATIVE_PIXMAP_KHR,
m_screenPixmaps[1],
0);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, img[1]);
if (img[0] == 0 || img[1] == 0) {
qWarning() << "Failed to create KHR images" << img[0] << img[1] << strerror(errno) << errno;
m_eglImageSupported = false;
} else {
m_eglImagesInitialized = true;
}
}
static int CreateTextureFromHandle(EGLDisplay egl_display,
buffer_handle_t handle,
AutoEGLImageAndGLTexture *out) {
EGLImageKHR image = eglCreateImageKHR(
egl_display, EGL_NO_CONTEXT, EGL_NATIVE_HANDLE_ANDROID_NVX,
(EGLClientBuffer)handle, NULL /* no attribs */);
if (image == EGL_NO_IMAGE_KHR) {
ALOGE("Failed to make image %s %p", GetEGLError(), handle);
return -EINVAL;
}
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
out->image.reset(image);
out->texture.reset(texture);
return 0;
}
bool AbstractEglTexture::loadTexture(xcb_pixmap_t pix, const QSize &size)
{
if (pix == XCB_NONE)
return false;
glGenTextures(1, &m_texture);
q->setWrapMode(GL_CLAMP_TO_EDGE);
q->setFilter(GL_LINEAR);
q->bind();
const EGLint attribs[] = {
EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
EGL_NONE
};
m_image = eglCreateImageKHR(m_backend->eglDisplay(), EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR,
(EGLClientBuffer)pix, attribs);
if (EGL_NO_IMAGE_KHR == m_image) {
qCDebug(KWIN_CORE) << "failed to create egl image";
q->unbind();
q->discard();
return false;
}
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)m_image);
q->unbind();
q->setYInverted(true);
m_size = size;
updateMatrix();
return true;
}
enum piglit_result
piglit_display(void)
{
GLuint tex;
enum piglit_result result = PIGLIT_FAIL;
const unsigned char src[] = { 0x00, 0x00, 0x00, 0x00 };
EGLImageKHR img = create_tex_based_egl_image(1, 1, src);
if (img == EGL_NO_IMAGE_KHR)
return PIGLIT_FAIL;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_EXTERNAL_OES, tex);
glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES,
(GLeglImageOES)img);
if (piglit_check_gl_error(GL_INVALID_OPERATION))
result = PIGLIT_PASS;
glDeleteTextures(1, &tex);
eglDestroyImageKHR(eglGetCurrentDisplay(), img);
return result;
}
// CAUTION: bind texture should in context thread only
status_t SurfaceTexture::bindToAuxSlotLocked() {
if (EGL_NO_IMAGE_KHR != mBackAuxSlot->eglSlot.mEglImage) {
AuxSlot *tmp = mBackAuxSlot;
mBackAuxSlot = mFrontAuxSlot;
mFrontAuxSlot = tmp;
glBindTexture(mTexTarget, mTexName);
glEGLImageTargetTexture2DOES(mTexTarget, (GLeglImageOES)mFrontAuxSlot->eglSlot.mEglImage);
// insert fence sync object just after new front texture applied
EGLSyncKHR eglFence = mFrontAuxSlot->eglSlot.mEglFence;
if (eglFence != EGL_NO_SYNC_KHR) {
XLOGI("[%s] fence sync already exists in mFrontAuxSlot:%p, destoryed it", __func__, mFrontAuxSlot);
eglDestroySyncKHR(mEglDisplay, eglFence);
}
eglFence = eglCreateSyncKHR(mEglDisplay, EGL_SYNC_FENCE_KHR, NULL);
if (eglFence == EGL_NO_SYNC_KHR) {
XLOGE("[%s] error creating fence: %#x", __func__, eglGetError());
}
glFlush();
mFrontAuxSlot->eglSlot.mEglFence = eglFence;
}
mAuxSlotDirty = false;
return NO_ERROR;
}
void QMeeGoLivePixmapData::initializeThroughEGLImage()
{
if (texture()->id != 0)
return;
QGLShareContextScope ctx(qt_gl_share_widget()->context());
QMeeGoExtensions::ensureInitialized();
EGLImageKHR eglImage = EGL_NO_IMAGE_KHR;
GLuint newTextureId = 0;
eglImage = QEgl::eglCreateImageKHR(QEgl::display(), EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR,
(EGLClientBuffer) backingX11Pixmap->handle(), preserved_attribs);
if (eglImage == EGL_NO_IMAGE_KHR) {
qWarning("eglCreateImageKHR failed (live texture)!");
return;
}
glGenTextures(1, &newTextureId);
glBindTexture(GL_TEXTURE_2D, newTextureId);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (EGLImageKHR) eglImage);
if (glGetError() == GL_NO_ERROR) {
resize(backingX11Pixmap->width(), backingX11Pixmap->height());
texture()->id = newTextureId;
texture()->options &= ~QGLContext::InvertedYBindOption;
m_hasAlpha = backingX11Pixmap->hasAlphaChannel();
} else {
qWarning("Failed to create a texture from an egl image (live texture)!");
glDeleteTextures(1, &newTextureId);
}
QEgl::eglDestroyImageKHR(QEgl::display(), eglImage);
}
void GLES20RenderEngine::bindImageAsFramebuffer(EGLImageKHR image,
uint32_t* texName, uint32_t* fbName, uint32_t* status,
bool useReadPixels, int reqWidth, int reqHeight) {
GLuint tname, name;
if (!useReadPixels) {
// turn our EGLImage into a texture
glGenTextures(1, &tname);
glBindTexture(GL_TEXTURE_2D, tname);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
// create a Framebuffer Object to render into
glGenFramebuffers(1, &name);
glBindFramebuffer(GL_FRAMEBUFFER, name);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tname, 0);
} else {
// since we're going to use glReadPixels() anyways,
// use an intermediate renderbuffer instead
glGenRenderbuffers(1, &tname);
glBindRenderbuffer(GL_RENDERBUFFER, tname);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8_OES, reqWidth, reqHeight);
// create a FBO to render into
glGenFramebuffers(1, &name);
glBindFramebuffer(GL_FRAMEBUFFER, name);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, tname);
}
*status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
*texName = tname;
*fbName = name;
}
void NativeImageGL2D::bindTexture()
{
if (m_texture)
glBindTexture(GL_TEXTURE_2D, m_texture);
else
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, reinterpret_cast<GLeglImageOES>(m_privateImageHandle));
}
GLuint FBO::createTexture(EGLImageKHR image, int width, int height)
{
LOGWEBGL("createTexture(image = %p)", image);
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
bool error = false;
if (image) {
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
error = (GraphicsContext3DInternal::checkGLError("glEGLImageTargetTexture2DOES")
!= GL_NO_ERROR);
}
else {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
error = (GraphicsContext3DInternal::checkGLError("glTexImage2D()") != GL_NO_ERROR);
}
glBindTexture(GL_TEXTURE_2D, 0);
if (error) {
glDeleteTextures(1, &texture);
texture = 0;
}
return texture;
}
status_t GLConsumer::bindUnslottedBufferLocked(EGLDisplay dpy) {
ST_LOGV("bindUnslottedBuffer ct=%d ctb=%p",
mCurrentTexture, mCurrentTextureBuf.get());
// Create a temporary EGLImageKHR.
Rect crop;
EGLImageKHR image = createImage(dpy, mCurrentTextureBuf, mCurrentCrop);
if (image == EGL_NO_IMAGE_KHR) {
return UNKNOWN_ERROR;
}
// Attach the current buffer to the GL texture.
glEGLImageTargetTexture2DOES(mTexTarget, (GLeglImageOES)image);
GLint error;
status_t err = OK;
while ((error = glGetError()) != GL_NO_ERROR) {
ST_LOGE("bindUnslottedBuffer: error binding external texture image %p "
"(slot %d): %#04x", image, mCurrentTexture, error);
err = UNKNOWN_ERROR;
}
// We destroy the EGLImageKHR here because the current buffer may no
// longer be associated with one of the buffer slots, so we have
// nowhere to to store it. If the buffer is still associated with a
// slot then another EGLImageKHR will be created next time that buffer
// gets acquired in updateTexImage.
eglDestroyImageKHR(dpy, image);
return err;
}
static GrBackendTexture make_gl_backend_texture(
GrContext* context, AHardwareBuffer* hardwareBuffer,
int width, int height, GrPixelConfig config,
GrAHardwareBufferImageGenerator::DeleteImageProc* deleteProc,
GrAHardwareBufferImageGenerator::DeleteImageCtx* deleteCtx,
bool isProtectedContent,
const GrBackendFormat& backendFormat) {
while (GL_NO_ERROR != glGetError()) {} //clear GL errors
EGLClientBuffer clientBuffer = eglGetNativeClientBufferANDROID(hardwareBuffer);
EGLint attribs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
isProtectedContent ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE,
isProtectedContent ? EGL_TRUE : EGL_NONE,
EGL_NONE };
EGLDisplay display = eglGetCurrentDisplay();
// eglCreateImageKHR will add a ref to the AHardwareBuffer
EGLImageKHR image = eglCreateImageKHR(display, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
clientBuffer, attribs);
if (EGL_NO_IMAGE_KHR == image) {
SkDebugf("Could not create EGL image, err = (%#x)", (int) eglGetError() );
return GrBackendTexture();
}
GrGLuint texID;
glGenTextures(1, &texID);
if (!texID) {
eglDestroyImageKHR(display, image);
return GrBackendTexture();
}
glBindTexture(GL_TEXTURE_EXTERNAL_OES, texID);
GLenum status = GL_NO_ERROR;
if ((status = glGetError()) != GL_NO_ERROR) {
SkDebugf("glBindTexture failed (%#x)", (int) status);
glDeleteTextures(1, &texID);
eglDestroyImageKHR(display, image);
return GrBackendTexture();
}
glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, image);
if ((status = glGetError()) != GL_NO_ERROR) {
SkDebugf("glEGLImageTargetTexture2DOES failed (%#x)", (int) status);
glDeleteTextures(1, &texID);
eglDestroyImageKHR(display, image);
return GrBackendTexture();
}
context->resetContext(kTextureBinding_GrGLBackendState);
GrGLTextureInfo textureInfo;
textureInfo.fID = texID;
SkASSERT(backendFormat.isValid());
textureInfo.fTarget = *backendFormat.getGLTarget();
textureInfo.fFormat = *backendFormat.getGLFormat();
*deleteProc = GrAHardwareBufferImageGenerator::DeleteGLTexture;
*deleteCtx = new GLCleanupHelper(texID, image, display);
return GrBackendTexture(width, height, GrMipMapped::kNo, textureInfo);
}
static GLuint
create_dma_buf_texture(uint32_t width, uint32_t height, uint32_t fourcc,
const void *pixels)
{
EGLDisplay dpy = eglGetCurrentDisplay();
enum piglit_result result = PIGLIT_PASS;
struct piglit_dma_buf *dma_buf;
EGLImageKHR image;
EGLint image_attrs[13];
GLuint tex;
int i;
result = piglit_create_dma_buf(width, height, fourcc, pixels, &dma_buf);
if (result != PIGLIT_PASS) {
piglit_loge("failed to create dma_buf");
piglit_report_result(result);
}
i = 0;
image_attrs[i++] = EGL_LINUX_DRM_FOURCC_EXT;
image_attrs[i++] = fourcc;
image_attrs[i++] = EGL_WIDTH;
image_attrs[i++] = width;
image_attrs[i++] = EGL_HEIGHT;
image_attrs[i++] = height;
image_attrs[i++] = EGL_DMA_BUF_PLANE0_FD_EXT;
image_attrs[i++] = dma_buf->fd;
image_attrs[i++] = EGL_DMA_BUF_PLANE0_PITCH_EXT;
image_attrs[i++] = dma_buf->stride[0];
image_attrs[i++] = EGL_DMA_BUF_PLANE0_OFFSET_EXT;
image_attrs[i++] = dma_buf->offset[0];
image_attrs[i++] = EGL_NONE;
image = eglCreateImageKHR(dpy, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT,
(EGLClientBuffer) NULL, image_attrs);
if (image == EGL_NO_IMAGE_KHR) {
piglit_loge("failed to create EGLImage from dma_buf");
piglit_report_result(PIGLIT_FAIL);
}
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES) image);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
return tex;
}
void QGLPixmapData::ensureCreated() const
{
if (!m_dirty)
return;
m_dirty = false;
if (nativeImageHandleProvider && !nativeImageHandle)
const_cast<QGLPixmapData *>(this)->createFromNativeImageHandleProvider();
QGLShareContextScope ctx(qt_gl_share_widget()->context());
m_ctx = ctx;
#ifdef QT_SYMBIAN_SUPPORTS_SGIMAGE
if (m_sgImage) {
qt_resolve_eglimage_gl_extensions(ctx); // ensure initialized
bool textureIsBound = false;
GLuint newTextureId;
EGLint imgAttr[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE };
EGLImageKHR image = QEgl::eglCreateImageKHR(QEgl::display()
, EGL_NO_CONTEXT
, EGL_NATIVE_PIXMAP_KHR
, (EGLClientBuffer)m_sgImage
, imgAttr);
glGenTextures(1, &newTextureId);
glBindTexture( GL_TEXTURE_2D, newTextureId);
if (image != EGL_NO_IMAGE_KHR) {
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
GLint err = glGetError();
if (err == GL_NO_ERROR)
textureIsBound = true;
QEgl::eglDestroyImageKHR(QEgl::display(), image);
}
if (textureIsBound) {
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
m_texture.id = newTextureId;
m_texture.boundPixmap = const_cast<QGLPixmapData*>(this);
QGLSgImageTextureCleanup::cleanupForContext(m_ctx)->insert(m_texture.id, const_cast<QGLPixmapData*>(this));
} else {
qWarning("QGLPixmapData: Failed to create texture from a SgImage image of size %dx%d", w, h);
glDeleteTextures(1, &newTextureId);
}
}
#endif
}
static cairo_surface_t *
display_create_drm_surface(struct display *display,
struct rectangle *rectangle)
{
struct drm_surface_data *data;
EGLDisplay dpy = display->dpy;
cairo_surface_t *surface;
struct wl_visual *visual;
EGLint name, stride;
EGLint image_attribs[] = {
EGL_WIDTH, 0,
EGL_HEIGHT, 0,
EGL_DRM_BUFFER_FORMAT_MESA, EGL_DRM_BUFFER_FORMAT_ARGB32_MESA,
EGL_DRM_BUFFER_USE_MESA, EGL_DRM_BUFFER_USE_SCANOUT_MESA,
EGL_NONE
};
data = malloc(sizeof *data);
if (data == NULL)
return NULL;
data->display = display;
image_attribs[1] = rectangle->width;
image_attribs[3] = rectangle->height;
data->image = eglCreateDRMImageMESA(dpy, image_attribs);
cairo_device_acquire(display->device);
glGenTextures(1, &data->texture);
glBindTexture(GL_TEXTURE_2D, data->texture);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, data->image);
cairo_device_release(display->device);
eglExportDRMImageMESA(display->dpy, data->image, &name, NULL, &stride);
visual = wl_display_get_premultiplied_argb_visual(display->display);
data->data.buffer =
wl_drm_create_buffer(display->drm, name, rectangle->width,
rectangle->height, stride, visual);
surface = cairo_gl_surface_create_for_texture(display->device,
CAIRO_CONTENT_COLOR_ALPHA,
data->texture,
rectangle->width,
rectangle->height);
cairo_surface_set_user_data (surface, &surface_data_key,
data, drm_surface_data_destroy);
return surface;
}
static enum piglit_result
sample_and_destroy_img(unsigned w, unsigned h, EGLImageKHR img)
{
GLuint prog, tex;
GLenum error;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_EXTERNAL_OES, tex);
/* Set the image as level zero */
glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES,
(GLeglImageOES)img);
error = glGetError();
/**
* EGL may not support binding of external textures, this is not an
* error.
*/
if (error == GL_INVALID_OPERATION)
return PIGLIT_SKIP;
if (error != GL_NO_ERROR) {
printf("glEGLImageTargetTexture2DOES() failed: %s 0x%x\n",
piglit_get_gl_error_name(error), error);
return PIGLIT_FAIL;
}
glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
prog = piglit_build_simple_program(vs_src, fs_src);
glUseProgram(prog);
glUniform1i(glGetUniformLocation(prog, "sampler"), 0);
set_vertices(prog);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, w, h);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDeleteProgram(prog);
glUseProgram(0);
glDeleteTextures(1, &tex);
eglDestroyImageKHR(eglGetCurrentDisplay(), img);
return PIGLIT_PASS;
}
void add_texture(struct client *client, struct cmd_buf *cbuf, int fd)
{
struct texture *texture;
EGLint attrs[13];
texture = calloc(1, sizeof(*texture));
if (!texture)
error(1, errno, "failed to create texture storage\n");
texture->rem_id = cbuf->u.buf.id;
attrs[0] = EGL_DMA_BUF_PLANE0_FD_EXT;
attrs[1] = fd;
attrs[2] = EGL_DMA_BUF_PLANE0_PITCH_EXT;
attrs[3] = cbuf->u.buf.stride;
attrs[4] = EGL_DMA_BUF_PLANE0_OFFSET_EXT;
attrs[5] = 0;
attrs[6] = EGL_WIDTH;
attrs[7] = cbuf->u.buf.width;
attrs[8] = EGL_HEIGHT;
attrs[9] = cbuf->u.buf.height;
attrs[10] = EGL_LINUX_DRM_FOURCC_EXT;
attrs[11] = cbuf->u.buf.format;
attrs[12] = EGL_NONE;
texture->image = eglCreateImageKHR(client->d->x11.egl_display,
EGL_NO_CONTEXT,
EGL_LINUX_DMA_BUF_EXT,
(EGLClientBuffer)NULL,
attrs);
if (!texture->image)
error(1, errno, "failed to import image dma-buf");
glGenTextures(1, &texture->local_id);
glBindTexture(GL_TEXTURE_2D, texture->local_id);
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
// glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 640, 480, 0,
// GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, (GLeglImageOES)texture->image);
if (!client->texhead)
client->texhead = texture;
else {
struct texture *iter = client->texhead;
while (iter->next)
iter = iter->next;
iter->next = texture;
}
}
static Bool
glamor_create_texture_from_image(struct glamor_egl_screen_private
*glamor_egl,
EGLImageKHR image, GLuint * texture)
{
glGenTextures(1, texture);
glBindTexture(GL_TEXTURE_2D, *texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
glBindTexture(GL_TEXTURE_2D, 0);
return TRUE;
}
GLuint
createTextureFromPixmap(EGLContextType *context, XID pixmap)
{
GLuint textureId;
EGLImageKHR image = eglCreateImageKHR(context->eglContext.display, context->eglContext.context, EGL_NATIVE_PIXMAP_KHR, (EGLClientBuffer)pixmap, NULL);
glGenTextures(1, &textureId );
glBindTexture(GL_TEXTURE_2D, textureId);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
return textureId;
}
status_t TextureManager::initEglImage(Image* pImage,
EGLDisplay dpy, const sp<GraphicBuffer>& buffer, EGLContext ctx)
{
status_t err = NO_ERROR;
if (!pImage->dirty) return err;
// free the previous image
if (pImage->image != EGL_NO_IMAGE_KHR) {
eglDestroyImageKHR(dpy, pImage->image);
pImage->image = EGL_NO_IMAGE_KHR;
}
// construct an EGL_NATIVE_BUFFER_ANDROID
android_native_buffer_t* clientBuf = buffer->getNativeBuffer();
// create the new EGLImageKHR
const EGLint attrs[] = {
EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
EGL_NONE, EGL_NONE
};
pImage->image = eglCreateImageKHR(
dpy, ctx, EGL_NATIVE_BUFFER_ANDROID,
(EGLClientBuffer)clientBuf, attrs);
if (pImage->image != EGL_NO_IMAGE_KHR) {
if (pImage->name == -1UL) {
initTexture(pImage, buffer->format);
}
const GLenum target = getTextureTarget(pImage);
glBindTexture(target, pImage->name);
glEGLImageTargetTexture2DOES(target, (GLeglImageOES)pImage->image);
GLint error = glGetError();
if (error != GL_NO_ERROR) {
LOGE("glEGLImageTargetTexture2DOES(%p) failed err=0x%04x",
pImage->image, error);
err = INVALID_OPERATION;
} else {
// Everything went okay!
pImage->dirty = false;
pImage->width = clientBuf->width;
pImage->height = clientBuf->height;
}
} else {
LOGE("eglCreateImageKHR() failed. err=0x%4x", eglGetError());
err = INVALID_OPERATION;
}
return err;
}
static PixmapPtr
xwl_glamor_create_pixmap_for_bo(ScreenPtr screen, struct gbm_bo *bo, int depth)
{
PixmapPtr pixmap;
struct xwl_pixmap *xwl_pixmap;
struct xwl_screen *xwl_screen = xwl_screen_get(screen);
xwl_pixmap = malloc(sizeof *xwl_pixmap);
if (xwl_pixmap == NULL)
return NULL;
pixmap = glamor_create_pixmap(screen,
gbm_bo_get_width(bo),
gbm_bo_get_height(bo),
depth,
GLAMOR_CREATE_PIXMAP_NO_TEXTURE);
if (pixmap == NULL) {
free(xwl_pixmap);
return NULL;
}
if (lastGLContext != xwl_screen->glamor_ctx) {
lastGLContext = xwl_screen->glamor_ctx;
xwl_glamor_egl_make_current(xwl_screen->glamor_ctx);
}
xwl_pixmap->bo = bo;
xwl_pixmap->buffer = NULL;
xwl_pixmap->image = eglCreateImageKHR(xwl_screen->egl_display,
xwl_screen->egl_context,
EGL_NATIVE_PIXMAP_KHR,
xwl_pixmap->bo, NULL);
glGenTextures(1, &xwl_pixmap->texture);
glBindTexture(GL_TEXTURE_2D, xwl_pixmap->texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, xwl_pixmap->image);
glBindTexture(GL_TEXTURE_2D, 0);
xwl_pixmap_set_private(pixmap, xwl_pixmap);
glamor_set_pixmap_texture(pixmap, xwl_pixmap->texture);
glamor_set_pixmap_type(pixmap, GLAMOR_TEXTURE_DRM);
return pixmap;
}
JNIEXPORT int JNICALL Java_com_nvidia_fcamerapro_FCamInterface_lockViewerTexture(JNIEnv *env, jobject thiz) {
FCam::Tegra::Hal::SharedBuffer *buffer = sAppData->tripleBuffer->swapFrontBuffer();
GLuint tid;
glGenTextures(1, &tid);
glBindTexture(GL_TEXTURE_EXTERNAL_OES, tid);
glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, (GLeglImageOES) buffer->getEGLImage());
glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
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);
sAppData->viewerBufferTexId = tid;
return tid;
}
void QMeeGoPixmapData::fromEGLSharedImage(Qt::HANDLE handle, const QImage &si)
{
if (si.isNull())
qFatal("Trying to build pixmap with an empty/null softimage!");
QGLShareContextScope ctx(qt_gl_share_widget()->context());
QMeeGoExtensions::ensureInitialized();
bool textureIsBound = false;
GLuint newTextureId;
GLint newWidth, newHeight;
glGenTextures(1, &newTextureId);
glBindTexture(GL_TEXTURE_2D, newTextureId);
glFinish();
EGLImageKHR image = QEgl::eglCreateImageKHR(QEgl::display(), EGL_NO_CONTEXT, EGL_SHARED_IMAGE_NOK,
(EGLClientBuffer)handle, preserved_image_attribs);
if (image != EGL_NO_IMAGE_KHR) {
glFinish();
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
GLint err = glGetError();
if (err == GL_NO_ERROR)
textureIsBound = true;
QMeeGoExtensions::eglQueryImageNOK(QEgl::display(), image, EGL_WIDTH, &newWidth);
QMeeGoExtensions::eglQueryImageNOK(QEgl::display(), image, EGL_HEIGHT, &newHeight);
QEgl::eglDestroyImageKHR(QEgl::display(), image);
glFinish();
}
if (textureIsBound) {
// FIXME Remove this ugly hasAlphaChannel check when Qt lands the NoOpaqueCheck flag fix
// for QGLPixmapData.
fromTexture(newTextureId, newWidth, newHeight,
(si.hasAlphaChannel() && const_cast<QImage &>(si).data_ptr()->checkForAlphaPixels()));
softImage = si;
QMeeGoPixmapData::registerSharedImage(handle, softImage);
} else {
qWarning("Failed to create a texture from a shared image!");
glDeleteTextures(1, &newTextureId);
}
}
void GLES20RenderEngine::bindImageAsFramebuffer(EGLImageKHR image,
uint32_t* texName, uint32_t* fbName, uint32_t* status) {
GLuint tname, name;
// turn our EGLImage into a texture
glGenTextures(1, &tname);
glBindTexture(GL_TEXTURE_2D, tname);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
// create a Framebuffer Object to render into
glGenFramebuffers(1, &name);
glBindFramebuffer(GL_FRAMEBUFFER, name);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tname, 0);
*status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
*texName = tname;
*fbName = name;
}
/**
* Advances the texture and EGL image to the next MMAL buffer.
*
* @param display The EGL display.
* @param target The EGL image target e.g. EGL_IMAGE_BRCM_MULTIMEDIA
* @param mm_buf The EGL client buffer (mmal opaque buffer) that is used to
* create the EGL Image for the preview texture.
* @param egl_image Pointer to the EGL image to update with mm_buf.
* @param texture Pointer to the texture to update from EGL image.
* @return Zero if successful.
*/
int raspitexutil_do_update_texture(EGLDisplay display, EGLenum target,
EGLClientBuffer mm_buf, GLuint *texture, EGLImageKHR *egl_image)
{
vcos_log_trace("%s: mm_buf %u", VCOS_FUNCTION, (unsigned) mm_buf);
GLCHK(glBindTexture(GL_TEXTURE_EXTERNAL_OES, *texture));
if (*egl_image != EGL_NO_IMAGE_KHR)
{
/* Discard the EGL image for the preview frame */
eglDestroyImageKHR(display, *egl_image);
*egl_image = EGL_NO_IMAGE_KHR;
}
*egl_image = eglCreateImageKHR(display, EGL_NO_CONTEXT, target, mm_buf, NULL);
GLCHK(glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, *egl_image));
return 0;
}
static bool
try_as_texture_2d(EGLImageKHR img)
{
GLuint tex;
bool res;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
/* Set the image as level zero */
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)img);
res = piglit_check_gl_error(GL_NO_ERROR);
glDeleteTextures(1, &tex);
return res;
}
static void
update_image (APP_STATE_T * state, GstBuffer * buffer)
{
GstMemory *mem = gst_buffer_peek_memory (buffer, 0);
if (state->current_mem) {
gst_memory_unref (state->current_mem);
}
state->current_mem = gst_memory_ref (mem);
TRACE_VC_MEMORY_ONCE_FOR_ID ("before glEGLImageTargetTexture2DOES", gid0);
glBindTexture (GL_TEXTURE_2D, state->tex);
glEGLImageTargetTexture2DOES (GL_TEXTURE_2D,
gst_egl_image_memory_get_image (mem));
TRACE_VC_MEMORY_ONCE_FOR_ID ("after glEGLImageTargetTexture2DOES", gid1);
}
GLuint WebGLLayer::createTexture(EGLImageKHR image, int width, int height)
{
LOGWEBGL("WebGLLayer::createTexture(image = %p)", image);
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
glBindTexture(GL_TEXTURE_2D, 0);
return texture;
}
status_t GLConsumer::bindTextureImageLocked() {
if (mEglDisplay == EGL_NO_DISPLAY) {
ALOGE("bindTextureImage: invalid display");
return INVALID_OPERATION;
}
GLint error;
while ((error = glGetError()) != GL_NO_ERROR) {
ST_LOGW("bindTextureImage: clearing GL error: %#04x", error);
}
glBindTexture(mTexTarget, mTexName);
if (mCurrentTexture == BufferQueue::INVALID_BUFFER_SLOT) {
if (mCurrentTextureBuf == NULL) {
ST_LOGE("bindTextureImage: no currently-bound texture");
return NO_INIT;
}
status_t err = bindUnslottedBufferLocked(mEglDisplay);
if (err != NO_ERROR) {
return err;
}
} else {
EGLImageKHR image = mEglSlots[mCurrentTexture].mEglImage;
glEGLImageTargetTexture2DOES(mTexTarget, (GLeglImageOES)image);
while ((error = glGetError()) != GL_NO_ERROR) {
ST_LOGE("bindTextureImage: error binding external texture image %p"
": %#04x", image, error);
return UNKNOWN_ERROR;
}
}
// Wait for the new buffer to be ready.
return doGLFenceWaitLocked();
}
Image::Image(sp<GraphicBuffer> buffer) {
// Create the EGLImage object that maps the GraphicBuffer
EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
EGLClientBuffer clientBuffer = (EGLClientBuffer) buffer->getNativeBuffer();
EGLint attrs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE };
mImage = eglCreateImageKHR(display, EGL_NO_CONTEXT,
EGL_NATIVE_BUFFER_ANDROID, clientBuffer, attrs);
if (mImage == EGL_NO_IMAGE_KHR) {
ALOGW("Error creating image (%#x)", eglGetError());
mTexture = 0;
} else {
// Create a 2D texture to sample from the EGLImage
glGenTextures(1, &mTexture);
Caches::getInstance().bindTexture(mTexture);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, mImage);
GLenum status = GL_NO_ERROR;
while ((status = glGetError()) != GL_NO_ERROR) {
ALOGW("Error creating image (%#x)", status);
}
}
}
EGLImageKHR AbstractEglTexture::attach(const QPointer< KWayland::Server::BufferInterface > &buffer)
{
EGLint format, yInverted;
eglQueryWaylandBufferWL(m_backend->eglDisplay(), buffer->resource(), EGL_TEXTURE_FORMAT, &format);
if (format != EGL_TEXTURE_RGB && format != EGL_TEXTURE_RGBA) {
qCDebug(KWIN_CORE) << "Unsupported texture format: " << format;
return EGL_NO_IMAGE_KHR;
}
eglQueryWaylandBufferWL(m_backend->eglDisplay(), buffer->resource(), EGL_WAYLAND_Y_INVERTED_WL, &yInverted);
const EGLint attribs[] = {
EGL_WAYLAND_PLANE_WL, 0,
EGL_NONE
};
EGLImageKHR image = eglCreateImageKHR(m_backend->eglDisplay(), EGL_NO_CONTEXT, EGL_WAYLAND_BUFFER_WL,
(EGLClientBuffer)buffer->resource(), attribs);
if (image != EGL_NO_IMAGE_KHR) {
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
m_size = buffer->size();
updateMatrix();
q->setYInverted(yInverted);
}
return image;
}