implement both overlay and fbtarget code paths

Author: sletta

include/backend/sfhwc/sfhwc.h

@@ -70,15 +70,21 @@ class SfHwcSurface : public SurfaceBackendImpl, public HWComposerNativeWindow
         return renderer;
     }
 
-       void present(HWComposerNativeWindowBuffer *buffer) override;
+    void present(HWComposerNativeWindowBuffer *buffer) override;
+    void presentAsOverlay(HWComposerNativeWindowBuffer *buffer);
+    void presentAsFramebufferTarget(HWComposerNativeWindowBuffer *buffer);
 
     Surface *m_surface;
     SfHwcBackend *m_backend;
 
+    std::list<SfHwcBuffer *> m_frameBuffers;
+
     double m_vsyncDelta;
     vec2 m_size;
     vec2 m_dpi;
 
+    bool m_useOverlay;
+
     hwc_display_contents_1_t *m_hwcList;
 
     EGLDisplay m_eglDisplay;
@@ -151,6 +157,9 @@ class SfHwcBuffer
 
     void fillWithCrap();
 
+    int fence() const { return m_fence; }
+    void setFence(int fd) { m_fence = fd; }
+
 private:
     gralloc_module_t *grallocModule() const { return m_backend->grallocModule; }
     alloc_device_t *allocDevice() const { return m_backend->allocDevice; }
@@ -161,6 +170,7 @@ class SfHwcBuffer
     int m_stride;
     int m_width;
     int m_height;
+    int m_fence;
 };
 
 #ifndef RENGINE_MAX_TOUCH_POINTS

include/backend/sfhwc/sfhwcbuffer.h

@@ -35,6 +35,7 @@ inline SfHwcBuffer::SfHwcBuffer(SfHwcBackend *backend, int w, int h, int format,
 	, m_stride(0)
 	, m_width(w)
 	, m_height(w)
+    , m_fence(-1)
 {
 	if (w == 0 || h == 0)
 		return;
@@ -136,4 +137,4 @@ inline void SfHwcBuffer::fillWithCrap()
     }
 }
 
-RENGINE_END_NAMESPACE
+RENGINE_END_NAMESPACE

include/backend/sfhwc/sfhwcsurface.h

@@ -120,7 +120,14 @@ inline SfHwcSurface::SfHwcSurface(Surface *surface, SfHwcBackend *backend, vec2
 	, m_backend(backend)
 	, m_vsyncDelta(0)
 	, m_size(size)
+    , m_useOverlay(false)
 {
+    char *overlay = getenv("RENGINE_SURFACE_USE_OVERLAY");
+    if (overlay && atoi(overlay) != 0) {
+        logi << "Using HWC_OVERLAY code path in HWC" << std::endl;
+        m_useOverlay = true;
+    }
+
     int bufferCount = 3;
     char *overrideBufferCount = getenv("RENGINE_SURFACE_BUFFER_COUNT");
     if (overrideBufferCount) {
@@ -189,15 +196,34 @@ inline void SfHwcSurface::initHwc()
     memset(m_hwcList, 0, size);
 
     m_hwcList->retireFenceFd = -1;
+    m_hwcList->outbufAcquireFenceFd = -1;
     m_hwcList->flags = HWC_GEOMETRY_CHANGED;
     m_hwcList->numHwLayers = 2;
 
     sfhwc_initialize_layer(&m_hwcList->hwLayers[0], HWC_FRAMEBUFFER, 0, 0, m_size.x, m_size.y);
-    m_hwcList->hwLayers[0].planeAlpha = 1;
+
+    // The Qualcomm HWC doesn't support planar alpha, so by setting 1 we force
+    // it  to take the GLES composited path, in which case, the
+    // HWC_FRAMEBUFFER_TARGET is used for direct presentation rather than
+    // composition.
+    if (m_useOverlay)
+        m_hwcList->hwLayers[0].planeAlpha = 255;
+    else
+        m_hwcList->hwLayers[0].planeAlpha = 1;
 
     sfhwc_initialize_layer(&m_hwcList->hwLayers[1], HWC_FRAMEBUFFER_TARGET, 0, 0, m_size.x, m_size.y);
     sfhwc_dump_display_contents(m_hwcList);
 
+    int bufferCount = 3;
+    char *overrideBufferCount = getenv("RENGINE_SURFACE_TARGETBUFFER_COUNT");
+    if (overrideBufferCount) {
+        bufferCount = std::max(1, std::min(atoi(overrideBufferCount), 10));
+    }
+    logi << "using " << bufferCount << " HWC_FRAMEBUFFER_TARGET buffers";
+    for (int i=0; i<bufferCount; ++i) {
+        SfHwcBuffer *buffer = new SfHwcBuffer(m_backend, 720, 1280, HAL_PIXEL_FORMAT_BGRA_8888, GRALLOC_USAGE_HW_COMPOSER);
+        m_frameBuffers.push_back(buffer);
+    }
 }
 
 inline void SfHwcSurface::initEgl()
@@ -253,115 +279,104 @@ inline void SfHwcSurface::initEgl()
 
 inline void SfHwcSurface::present(HWComposerNativeWindowBuffer *buffer)
 {
-	// logw << "buffer=" << (void *) buffer << std::endl;
-
-    int status = 0; (void) status;
-
-    static SfHwcBuffer *staticBuffer = 0;
-    if (!staticBuffer) {
-        staticBuffer = new SfHwcBuffer(m_backend, 720, 1280);
-        staticBuffer->lock();
-        staticBuffer->fillWithCrap();
-        staticBuffer->unlock();
-    }
+    static auto lastFrame = std::chrono::steady_clock::now();
+    auto thisFrame = std::chrono::steady_clock::now();
+    auto delta = std::chrono::duration_cast<std::chrono::milliseconds>(thisFrame - lastFrame).count();
+    if (delta > 30)
+        logw << "MISSED A FRAME: " << delta << std::endl;
+    lastFrame = thisFrame;
+
+    if (m_useOverlay)
+        presentAsOverlay(buffer);
+    else
+        presentAsFramebufferTarget(buffer);
+}
 
-    static SfHwcBuffer *staticBuffer2 = 0;
-    if (!staticBuffer2) {
-        staticBuffer2 = new SfHwcBuffer(m_backend, 720, 1280);
-        staticBuffer2->lock();
-        staticBuffer2->fillWithCrap();
-        staticBuffer2->unlock();
-    }
+inline void SfHwcSurface::presentAsOverlay(HWComposerNativeWindowBuffer *buffer)
+{
+    logw << "buffer=" << (void *) buffer << std::endl;
 
-	hwc_composer_device_1_t *hwc = m_backend->hwcDevice;
+    int status = 0; (void) status;
 
-    // static auto lastFrame = std::chrono::steady_clock::now();
-    // auto thisFrame = std::chrono::steady_clock::now();
-    // auto delta = std::chrono::duration_cast<std::chrono::milliseconds>(thisFrame - lastFrame).count();
-    // if (delta > 30)
-    //     logw << "MISSED A FRAME: " << delta << std::endl;
-    // lastFrame = thisFrame;
+    hwc_composer_device_1_t *hwc = m_backend->hwcDevice;
 
     int fd = getFenceBufferFd(buffer);
     setFenceBufferFd(buffer, -1);
-#if 0
-    if (fd != -1) {
-        auto start = std::chrono::steady_clock::now();
-        sync_wait(fd, -1);
-        close(fd);
-        auto end = std::chrono::steady_clock::now();
-        auto delta = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() / 1000.0;
-        logw << " - sync waited on libhybris buffer: "  << delta << ", buffer=" << buffer << std::endl;
-        fd = -1;
-    }
-#endif
 
-	hwc_layer_1_t *fb = &m_hwcList->hwLayers[0];
-	fb->handle = staticBuffer->handle();
-	fb->acquireFenceFd = -1;
-	fb->releaseFenceFd = -1;
-    fb->blending = 1;
-
-    static int counter = 0;
-    counter = counter == 1 ? 0 : 1;
+    hwc_layer_1_t *fb = &m_hwcList->hwLayers[0];
+    fb->handle = buffer->handle;
+    fb->acquireFenceFd = fd;
+    fb->releaseFenceFd = -1;
 
 	hwc_layer_1_t *fbt = &m_hwcList->hwLayers[1];
-	fbt->handle = buffer->handle;
-	fbt->acquireFenceFd = fd;
+	fbt->handle = m_frameBuffers.front()->handle();
+	fbt->acquireFenceFd = m_frameBuffers.front()->fence();
 	fbt->releaseFenceFd = -1;
 
-    // sfhwc_dump_display_contents(m_hwcList);
-    // sfhwc_dump_hwc_device(hwc);
+    // advance the framebuffers..
+    m_frameBuffers.push_back(m_frameBuffers.front());
+    m_frameBuffers.pop_front();
+
+	status = hwc->prepare(hwc, 1, &m_hwcList); assert(status == 0);
+	status = hwc->set(hwc, 1, &m_hwcList); assert(status == 0);
+
+    sfhwc_dump_hwc_device(hwc);
+
+    if (fb->releaseFenceFd != -1) {
+        setFenceBufferFd(buffer, fb->releaseFenceFd);
+        fb->releaseFenceFd = -1;
+    }
+
+    // cycle the framebuffer target
+    m_frameBuffers.back()->setFence(fbt->releaseFenceFd);
+
+	if (m_hwcList->retireFenceFd != -1) {
+		close(m_hwcList->retireFenceFd);
+        m_hwcList->retireFenceFd = -1;
+	}
+}
 
-	status = hwc->prepare(hwc, 1, &m_hwcList);
-	assert(status == 0);
-    // sfhwc_dump_display_contents(m_hwcList);
-    // sfhwc_dump_hwc_device(hwc);
+inline void SfHwcSurface::presentAsFramebufferTarget(HWComposerNativeWindowBuffer *buffer)
+{
+    logw << "buffer=" << (void *) buffer << std::endl;
 
-    // auto start = std::chrono::steady_clock::now();
+    int status = 0; (void) status;
 
-    // logi << " --> calling set" << std::endl;
+    hwc_composer_device_1_t *hwc = m_backend->hwcDevice;
 
-	status = hwc->set(hwc, 1, &m_hwcList);
+    int fd = getFenceBufferFd(buffer);
+    setFenceBufferFd(buffer, -1);
 
-    // logi << " <-- set completed" << std::endl;
+    hwc_layer_1_t *fb = &m_hwcList->hwLayers[0];
+    // Just pass a dummy handle that we have, we're not using these anyway..
+    fb->handle = m_frameBuffers.front()->handle();
+    fb->acquireFenceFd = -1;
+    fb->releaseFenceFd = -1;
 
-	assert(status == 0);
-    // sfhwc_dump_hwc_device(hwc);
+    hwc_layer_1_t *fbt = &m_hwcList->hwLayers[1];
+    fbt->handle = buffer->handle;
+    fbt->acquireFenceFd = fd;
+    fbt->releaseFenceFd = -1;
 
-    // auto end = std::chrono::steady_clock::now();
-    // auto delta = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() / 1000.0;
+    status = hwc->prepare(hwc, 1, &m_hwcList); assert(status == 0);
+    status = hwc->set(hwc, 1, &m_hwcList); assert(status == 0);
 
-    // logw << " - set completed in " << delta << std::endl;
+    if (fbt->releaseFenceFd != -1) {
+        setFenceBufferFd(buffer, fbt->releaseFenceFd);
+        fbt->releaseFenceFd = -1;
+    }
 
+    // Since we're taking the fb target code path, this buffer should be unused
+    // so this should in theory never happen...
     if (fb->releaseFenceFd != -1) {
-#if 1
-        setFenceBufferFd(buffer, fb->releaseFenceFd);
-        fb->releaseFenceFd = -1;
-#else
-        auto start = std::chrono::steady_clock::now();
-        sync_wait(fb->releaseFenceFd, -1);
         close(fb->releaseFenceFd);
         fb->releaseFenceFd = -1;
-        auto end = std::chrono::steady_clock::now();
-        auto delta = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() / 1000.0;
-        logw << " - waited for fb release fd, " << delta << std::endl;
-#endif
     }
 
-    if (fbt->releaseFenceFd != -1) {
-        close(fbt->releaseFenceFd);
-        fbt->releaseFenceFd = -1;
-        // logw << " - closed fbt release fd" << std::endl;
+    if (m_hwcList->retireFenceFd != -1) {
+        close(m_hwcList->retireFenceFd);
+        m_hwcList->retireFenceFd = -1;
     }
-
-	if (m_hwcList->retireFenceFd != -1) {
-		close(m_hwcList->retireFenceFd);
-		m_hwcList->retireFenceFd = -1;
-        // logw << " - closed retire fence fd.." << std::endl;
-	}
-
-    // logd << " -> frame on screen" << std::endl;
 }
 
 RENGINE_END_NAMESPACE