fix hardware buffer aidl

src/main/cpp/mosis-test.cpp

@@ -1,18 +1,55 @@
 #include <jni.h>
 #include <android/binder_ibinder_jni.h>
 #include <aidl/com/omixlab/mosis/IMosisService.h>
+#include <aidl/com/omixlab/mosis/IMosisListener.h>
+#include <aidl/com/omixlab/mosis/BnMosisListener.h>
 #include <android/native_window_jni.h>
 #include "logger.h"
 #include "egl_context.h"
 #include <glad/gles2.h>
+#include <glad/egl.h>
 #include <memory>
 #include <thread>
 
 using namespace aidl::com::omixlab::mosis;
+using namespace aidl::android::hardware;
 
-class Renderer
+class Shader
+{
+
+};
+
+class ImportedTexture
+{
+    GLuint texture = 0;
+public:
+    bool create(AHardwareBuffer* hardwareBuffer)
+    {
+        AHardwareBuffer_Desc desc{};
+        AHardwareBuffer_describe(hardwareBuffer, &desc);
+        EGLClientBuffer clientBuffer = eglGetNativeClientBufferANDROID(hardwareBuffer);
+        EGLImageKHR eglImage = eglCreateImageKHR(eglGetCurrentDisplay(), EGL_NO_CONTEXT,
+            EGL_NATIVE_BUFFER_ANDROID, clientBuffer, nullptr);
+        if (eglImage == EGL_NO_IMAGE_KHR)
+        {
+            Logger::Log("Failed to create EGL image");
+            return false;
+        }
+        glGenTextures(1, &texture);
+        glBindTexture(GL_TEXTURE_2D, texture);
+        glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, eglImage);
+        eglDestroyImageKHR(eglGetCurrentDisplay(), eglImage);
+        glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        return true;
+    }
+};
+
+class Renderer : public BnMosisListener
 {
     std::unique_ptr<egl::Context> m_egl_context;
+    std::unique_ptr<ImportedTexture> m_texture;
+    AHardwareBuffer* m_hwbuffer = nullptr;
     std::thread m_render_loop;
     bool m_active = false;
     void render_loop(ANativeWindow* window)
@@ -23,6 +60,14 @@ class Renderer
             m_active = true;
             while (m_active)
             {
+                if (m_hwbuffer && !m_texture)
+                {
+                    m_texture = std::make_unique<ImportedTexture>();
+                    if (!m_texture->create(m_hwbuffer))
+                    {
+                        Logger::Log("Failed to create texture");
+                    }
+                }
                 render_frame();
             }
         }
@@ -35,9 +80,14 @@ class Renderer
     {
         glClearColor(0.f, 0.5f, 0.5f, 1.0f);
         glClear(GL_COLOR_BUFFER_BIT);
+        if (m_texture)
+        {
+
+        }
         m_egl_context->swap();
     }
 public:
+    Renderer() = default;
     bool create(ANativeWindow* window)
     {
         m_render_loop = std::thread(&Renderer::render_loop, this, window);
@@ -51,10 +101,25 @@ public:
         m_egl_context->destroy();
         m_egl_context.reset();
     }
+    ndk::ScopedAStatus onServiceInitialized(bool in_success) override
+    {
+        return ndk::ScopedAStatus::ok();
+    }
+    ndk::ScopedAStatus onFrameAvailable() override
+    {
+        Logger::Log("onFrameAvailable");
+        return ndk::ScopedAStatus::ok();
+    }
+    ndk::ScopedAStatus onBufferAvailable(const HardwareBuffer &in_buffer) override
+    {
+        m_hwbuffer = in_buffer.get();
+        AHardwareBuffer_acquire(m_hwbuffer);
+        return ndk::ScopedAStatus::ok();
+    }
 };
 
 std::shared_ptr<IMosisService> g_service;
-std::unique_ptr<Renderer> g_renderer;
+std::shared_ptr<Renderer> g_renderer;
 
 extern "C"
 JNIEXPORT void JNICALL
@@ -67,6 +132,17 @@ Java_com_omixlab_mosis_MainActivity_serviceConnected(JNIEnv *env, jobject thiz,
     Logger::Log("Service Connected");
 }
 
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_omixlab_mosis_MainActivity_initOS(JNIEnv *env, jobject thiz)
+{
+    if (g_service && g_renderer)
+    {
+        bool result{};
+        g_service->initOS(g_renderer, &result);
+    }
+}
+
 extern "C"
 JNIEXPORT void JNICALL
 Java_com_omixlab_mosis_MainActivity_setSurface(JNIEnv *env, jobject thiz,
@@ -75,7 +151,7 @@ Java_com_omixlab_mosis_MainActivity_setSurface(JNIEnv *env, jobject thiz,
     Logger::Log("setSurface");
     if (!g_renderer)
     {
-        g_renderer = std::make_unique<Renderer>();
+        g_renderer = ndk::SharedRefBase::make<Renderer>();
         g_renderer->create(ANativeWindow_fromSurface(env, surface));
     }
 }