Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d26915c2 authored by Jerome Gaillard's avatar Jerome Gaillard
Browse files

Use CPU rendering for host builds

This bypasses the computation of PipelineRenderType on host to force
using the CPU rendering pipeline.

Bug: 322360037
Test: build libhwui on host
Change-Id: Icb5178ba04e5348868c6c7f637e0c7a341fc84cd
parent 35a873ce
Loading
Loading
Loading
Loading
+106 −0
Original line number Diff line number Diff line
/*
 * Copyright (C) 2024 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <system/window.h>

static int32_t query(ANativeWindow* window, int what) {
    int value;
    int res = window->query(window, what, &value);
    return res < 0 ? res : value;
}

static int64_t query64(ANativeWindow* window, int what) {
    int64_t value;
    int res = window->perform(window, what, &value);
    return res < 0 ? res : value;
}

int ANativeWindow_setCancelBufferInterceptor(ANativeWindow* window,
                                             ANativeWindow_cancelBufferInterceptor interceptor,
                                             void* data) {
    return window->perform(window, NATIVE_WINDOW_SET_CANCEL_INTERCEPTOR, interceptor, data);
}

int ANativeWindow_setDequeueBufferInterceptor(ANativeWindow* window,
                                              ANativeWindow_dequeueBufferInterceptor interceptor,
                                              void* data) {
    return window->perform(window, NATIVE_WINDOW_SET_DEQUEUE_INTERCEPTOR, interceptor, data);
}

int ANativeWindow_setQueueBufferInterceptor(ANativeWindow* window,
                                            ANativeWindow_queueBufferInterceptor interceptor,
                                            void* data) {
    return window->perform(window, NATIVE_WINDOW_SET_QUEUE_INTERCEPTOR, interceptor, data);
}

int ANativeWindow_setPerformInterceptor(ANativeWindow* window,
                                        ANativeWindow_performInterceptor interceptor, void* data) {
    return window->perform(window, NATIVE_WINDOW_SET_PERFORM_INTERCEPTOR, interceptor, data);
}

int ANativeWindow_dequeueBuffer(ANativeWindow* window, ANativeWindowBuffer** buffer, int* fenceFd) {
    return window->dequeueBuffer(window, buffer, fenceFd);
}

int ANativeWindow_cancelBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd) {
    return window->cancelBuffer(window, buffer, fenceFd);
}

int ANativeWindow_setDequeueTimeout(ANativeWindow* window, int64_t timeout) {
    return window->perform(window, NATIVE_WINDOW_SET_DEQUEUE_TIMEOUT, timeout);
}

// extern "C", so that it can be used outside libhostgraphics (in host hwui/.../CanvasContext.cpp)
extern "C" void ANativeWindow_tryAllocateBuffers(ANativeWindow* window) {
    if (!window || !query(window, NATIVE_WINDOW_IS_VALID)) {
        return;
    }
    window->perform(window, NATIVE_WINDOW_ALLOCATE_BUFFERS);
}

int64_t ANativeWindow_getLastDequeueStartTime(ANativeWindow* window) {
    return query64(window, NATIVE_WINDOW_GET_LAST_DEQUEUE_START);
}

int64_t ANativeWindow_getLastDequeueDuration(ANativeWindow* window) {
    return query64(window, NATIVE_WINDOW_GET_LAST_DEQUEUE_DURATION);
}

int64_t ANativeWindow_getLastQueueDuration(ANativeWindow* window) {
    return query64(window, NATIVE_WINDOW_GET_LAST_QUEUE_DURATION);
}

int32_t ANativeWindow_getWidth(ANativeWindow* window) {
    return query(window, NATIVE_WINDOW_WIDTH);
}

int32_t ANativeWindow_getHeight(ANativeWindow* window) {
    return query(window, NATIVE_WINDOW_HEIGHT);
}

int32_t ANativeWindow_getFormat(ANativeWindow* window) {
    return query(window, NATIVE_WINDOW_FORMAT);
}

void ANativeWindow_acquire(ANativeWindow* window) {
    // incStrong/decStrong token must be the same, doesn't matter what it is
    window->incStrong((void*)ANativeWindow_acquire);
}

void ANativeWindow_release(ANativeWindow* window) {
    // incStrong/decStrong token must be the same, doesn't matter what it is
    window->decStrong((void*)ANativeWindow_acquire);
}
+1 −0
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ cc_library_host_static {
    srcs: [
        ":libui_host_common",
        "ADisplay.cpp",
        "ANativeWindow.cpp",
        "Fence.cpp",
        "HostBufferQueue.cpp",
        "PublicFormat.cpp",
+5 −2
Original line number Diff line number Diff line
@@ -96,6 +96,7 @@ cc_defaults {
            ],
            cflags: [
                "-Wno-unused-variable",
                "-D__INTRODUCED_IN(n)=",
            ],
        },
    },
@@ -539,6 +540,7 @@ cc_defaults {
        "pipeline/skia/ReorderBarrierDrawables.cpp",
        "pipeline/skia/TransformCanvas.cpp",
        "renderstate/RenderState.cpp",
        "renderthread/CanvasContext.cpp",
        "renderthread/Frame.cpp",
        "renderthread/RenderTask.cpp",
        "renderthread/TimeLord.cpp",
@@ -589,6 +591,7 @@ cc_defaults {
        "SkiaCanvas.cpp",
        "SkiaInterpolator.cpp",
        "Tonemapper.cpp",
        "TreeInfo.cpp",
        "VectorDrawable.cpp",
    ],

@@ -617,7 +620,6 @@ cc_defaults {
                "pipeline/skia/VkFunctorDrawable.cpp",
                "pipeline/skia/VkInteropFunctorDrawable.cpp",
                "renderthread/CacheManager.cpp",
                "renderthread/CanvasContext.cpp",
                "renderthread/DrawFrameTask.cpp",
                "renderthread/EglManager.cpp",
                "renderthread/ReliableSurface.cpp",
@@ -636,7 +638,6 @@ cc_defaults {
                "Layer.cpp",
                "ProfileDataContainer.cpp",
                "Readback.cpp",
                "TreeInfo.cpp",
                "WebViewFunctorManager.cpp",
                "protos/graphicsstats.proto",
            ],
@@ -654,6 +655,8 @@ cc_defaults {

            srcs: [
                "platform/host/renderthread/CacheManager.cpp",
                "platform/host/renderthread/HintSessionWrapper.cpp",
                "platform/host/renderthread/ReliableSurface.cpp",
                "platform/host/renderthread/RenderThread.cpp",
                "platform/host/ProfileDataContainer.cpp",
                "platform/host/Readback.cpp",
+2 −0
Original line number Diff line number Diff line
@@ -164,8 +164,10 @@ static vector<string> parseCsv(JNIEnv* env, jstring csvJString) {
} // namespace android

using namespace android;
using namespace android::uirenderer;

void init_android_graphics() {
    Properties::overrideRenderPipelineType(RenderPipelineType::SkiaCpu);
    SkGraphics::Init();
}

+9 −0
Original line number Diff line number Diff line
@@ -50,6 +50,8 @@ ASurfaceControl* WebViewFunctor::getSurfaceControl() {

void WebViewFunctor::mergeTransaction(ASurfaceTransaction* transaction) {}

void WebViewFunctor::reportRenderingThreads(const int32_t* thread_ids, size_t size) {}

void WebViewFunctor::reparentSurfaceControl(ASurfaceControl* parent) {}

WebViewFunctorManager& WebViewFunctorManager::instance() {
@@ -68,6 +70,13 @@ void WebViewFunctorManager::onContextDestroyed() {}

void WebViewFunctorManager::destroyFunctor(int functor) {}

void WebViewFunctorManager::reportRenderingThreads(int functor, const int32_t* thread_ids,
                                                   size_t size) {}

std::vector<int32_t> WebViewFunctorManager::getRenderingThreadsForActiveFunctors() {
    return std::vector<int32_t>();
}

sp<WebViewFunctor::Handle> WebViewFunctorManager::handleFor(int functor) {
    return nullptr;
}
Loading