How can I pass a java HardwareBuffer to Texture on android platform?

[JungleKong]

I want to use a share texture provided by another process, represented by HardwareBuffer.
When I try to pass it to Filament Texture, but setExternalImage takes the EGLImage as parameter.

So I tried to add an API to OpenGLDriver, it looks like that:

void OpenGLDriver::setExternalHardwareBuffer(Handle<HwTexture> th, void* hwbuffer) {
    GLTexture* t = handle_cast<GLTexture*>(th);
    assert(t);

    AcquiredImage acquiredImage = mPlatform.transformAcquiredImage({
            hwbuffer, nullptr, nullptr, nullptr });

    bindTexture(OpenGLContext::DUMMY_TEXTURE_BINDING, t);
    if (mPlatform.setExternalImage(acquiredImage.image, t->externalTexture)) {
        // the target and id can be reset each time
        t->gl.target = t->externalTexture->target;
        t->gl.id = t->externalTexture->id;
        t->gl.targetIndex = (uint8_t)OpenGLContext::getIndexForTextureTarget(t->gl.target);
        bindTexture(OpenGLContext::DUMMY_TEXTURE_BINDING, t);
    }
}

Then a Texture JNI interface will be OK as usual, an I call it

val texture = Texture.Builder()
                .width(1024)
                .height(1024)
                .sampler(Texture.Sampler.SAMPLER_EXTERNAL)
                .format(Texture.InternalFormat.RGBA8)
                .levels(1)
                .build(engine)
texture.setExternalHardwareBuffer(engine, hardwareBuffer)

I am certain that the hardwareBuffer can lock right value in native(OpenGLDriver::setExternalHardwareBuffer), it just dose not work.
So, where did I go wrong, and how can I fix it?

---

By the way, if I gen Texture in Java directly and then bind texId with HardwareBuffer, it works very well.
It looks like as bellow:
At fisrt, I create Engine use Java EGL context, engine = Engine.create(sharedContext)
and then gen Texture ID and prepare AHardwareBuffer, pass them to native cpp

EGLClientBuffer clientBuffer = glext::eglGetNativeClientBufferANDROID(buffer);
EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
EGLint eglImageAttributes[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
EGLImageKHR eglImage = glext::eglCreateImageKHR(display, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
                                   clientBuffer, eglImageAttributes);
glBindTexture(GL_TEXTURE_2D, texId);
glext::glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES) eglImage);

In Java, pass the texId to Filament Texture

val texture = Texture.Builder()
                .width(1024)
                .height(1024)
                .sampler(Texture.Sampler.SAMPLER_2D)
                .format(Texture.InternalFormat.RGBA8)
                .importTexture(texId)
                .levels(1)
                .build(engine)

Or how can I share Texture between two Filament processes？

[pixelflinger]

I converted this issue to a discussion. I will try to answer asap.

[JungleKong]

I have the correct result when I use both Texture.Sampler.SAMPLER_2D as Server OUT, and Texture.Sampler.SAMPLER_2D as Client IN.

Define as follows:

// OpenGLDriver.cpp
void OpenGLDriver::setExternalHardwareBuffer(Handle<HwTexture> th, void* hwbuffer) {
    GLTexture* t = handle_cast<GLTexture*>(th);
    assert(t);

    AcquiredImage acquiredImage = mPlatform.transformAcquiredImage({
        hwbuffer, nullptr, nullptr, nullptr });
        
    mPlatform.transformExternalHardwareBuffer(&acquiredImage, t->gl.id);
    
    // for destroy EGLImageKHR
    t->eglImage = acquiredImage;
}

// PlatformEGL.cpp
void PlatformEGL::transformExternalHardwareBuffer(AcquiredImage* source, unsigned int texId) {
#ifdef GL_OES_EGL_image
    glBindTexture(GL_TEXTURE_2D, texId);
    glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES) source->image);
#endif
}

Usage as follows:

// server process creates a hwbuffer and bind to texture
public HardwareBuffer init(int renderWidth, int renderHeight) {
    Log.i(TAG, "AIDL call: init");

    // static JNI native method create a HardwareBuffer
    HardwareBuffer hwBuffer = Texture.getHardwareBuffer(renderWidth, renderHeight);
    Texture texture = new Texture.Builder()
        .width(renderWidth)
        .height(renderHeight)
        .levels(1)
        .sampler(Texture.Sampler.SAMPLER_2D)
        .format(Texture.InternalFormat.RGBA8)
        .build(engine);

    // bind hwbuffer to texture
    texture.setExternalHardwareBuffer(engine, hwBuffer);
    
    // fill data
    BitmapFactory.Options options = new BitmapFactory.Options();
    Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.cat, options);
    TextureHelper.setBitmap(engine, texture, 0, bitmap);
    // flush command
    engine.flushAndWait();
    return hwBuffer;
}

// client process gets hwbuffer and bind to texture
private void loadServerTexture(Engine engine) {
    Texture texture = new Texture.Builder()
            .width(renderWidth)
            .height(renderHeight)
            .sampler(Texture.Sampler.SAMPLER_2D)
            .format(Texture.InternalFormat.RGBA8)
            .levels(1)
            .build(engine)
    
    // get server hwbuffer 
    hwbuffer = aidlInterface.init(renderWidth, renderHeight)
    texture.setExternalHardwareBuffer(engine, hwbuffer)

    TextureSampler sampler = TextureSampler()
    sampler.anisotropy = 8.0f

    materialInstance.setParameter("baseColor", texture, sampler)
}

The key point seems to be that the texture format must be SAMPLER_2D rather than SAMPLER_EXTERNAL.