graphics/composer/2.1/utils/hwc2onfbadapter/HWC2OnFbAdapter.cpp

/*
 * Copyright 2017 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.
 */

#define LOG_TAG "HWC2OnFbAdapter"

//#define LOG_NDEBUG 0

#include "hwc2onfbadapter/HWC2OnFbAdapter.h"

#include <algorithm>
#include <type_traits>

#include <inttypes.h>
#include <time.h>
#include <sys/prctl.h>
#include <unistd.h> // for close

#include <hardware/fb.h>
#include <log/log.h>
#include <sync/sync.h>

using namespace HWC2;

namespace android {

namespace {

void dumpHook(hwc2_device_t* device, uint32_t* outSize, char* outBuffer) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (outBuffer) {
        *outSize = adapter.getDebugString().copy(outBuffer, *outSize);
    } else {
        adapter.updateDebugString();
        *outSize = adapter.getDebugString().size();
    }
}

int32_t registerCallbackHook(hwc2_device_t* device, int32_t descriptor,
                             hwc2_callback_data_t callbackData, hwc2_function_pointer_t pointer) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    switch (descriptor) {
        case HWC2_CALLBACK_HOTPLUG:
            if (pointer) {
                reinterpret_cast<HWC2_PFN_HOTPLUG>(pointer)(callbackData, adapter.getDisplayId(),
                                                            HWC2_CONNECTION_CONNECTED);
            }
            break;
        case HWC2_CALLBACK_REFRESH:
            break;
        case HWC2_CALLBACK_VSYNC:
            adapter.setVsyncCallback(reinterpret_cast<HWC2_PFN_VSYNC>(pointer), callbackData);
            break;
        default:
            return HWC2_ERROR_BAD_PARAMETER;
    }

    return HWC2_ERROR_NONE;
}

uint32_t getMaxVirtualDisplayCountHook(hwc2_device_t* /*device*/) {
    return 0;
}

int32_t createVirtualDisplayHook(hwc2_device_t* /*device*/, uint32_t /*width*/, uint32_t /*height*/,
                                 int32_t* /*format*/, hwc2_display_t* /*outDisplay*/) {
    return HWC2_ERROR_NO_RESOURCES;
}

int32_t destroyVirtualDisplayHook(hwc2_device_t* /*device*/, hwc2_display_t /*display*/) {
    return HWC2_ERROR_BAD_DISPLAY;
}

int32_t setOutputBufferHook(hwc2_device_t* /*device*/, hwc2_display_t /*display*/,
                            buffer_handle_t /*buffer*/, int32_t /*releaseFence*/) {
    return HWC2_ERROR_BAD_DISPLAY;
}

int32_t getDisplayNameHook(hwc2_device_t* device, hwc2_display_t display, uint32_t* outSize,
                           char* outName) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    const auto& info = adapter.getInfo();
    if (outName) {
        *outSize = info.name.copy(outName, *outSize);
    } else {
        *outSize = info.name.size();
    }

    return HWC2_ERROR_NONE;
}

int32_t getDisplayTypeHook(hwc2_device_t* device, hwc2_display_t display, int32_t* outType) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    *outType = HWC2_DISPLAY_TYPE_PHYSICAL;
    return HWC2_ERROR_NONE;
}

int32_t getDozeSupportHook(hwc2_device_t* device, hwc2_display_t display, int32_t* outSupport) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    *outSupport = 0;
    return HWC2_ERROR_NONE;
}

int32_t getHdrCapabilitiesHook(hwc2_device_t* device, hwc2_display_t display, uint32_t* outNumTypes,
                               int32_t* /*outTypes*/, float* /*outMaxLuminance*/,
                               float* /*outMaxAverageLuminance*/, float* /*outMinLuminance*/) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    *outNumTypes = 0;
    return HWC2_ERROR_NONE;
}

int32_t setPowerModeHook(hwc2_device_t* device, hwc2_display_t display, int32_t /*mode*/) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    // pretend that it works
    return HWC2_ERROR_NONE;
}

int32_t setVsyncEnabledHook(hwc2_device_t* device, hwc2_display_t display, int32_t enabled) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    adapter.enableVsync(enabled == HWC2_VSYNC_ENABLE);
    return HWC2_ERROR_NONE;
}

int32_t getColorModesHook(hwc2_device_t* device, hwc2_display_t display, uint32_t* outNumModes,
                          int32_t* outModes) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    if (outModes) {
        if (*outNumModes > 0) {
            outModes[0] = HAL_COLOR_MODE_NATIVE;
            *outNumModes = 1;
        }
    } else {
        *outNumModes = 1;
    }

    return HWC2_ERROR_NONE;
}

int32_t setColorModeHook(hwc2_device_t* device, hwc2_display_t display, int32_t mode) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }
    if (mode != HAL_COLOR_MODE_NATIVE) {
        return HWC2_ERROR_BAD_PARAMETER;
    }

    return HWC2_ERROR_NONE;
}

int32_t setColorTransformHook(hwc2_device_t* device, hwc2_display_t display,
                              const float* /*matrix*/, int32_t /*hint*/) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    // we always force client composition
    adapter.setState(HWC2OnFbAdapter::State::MODIFIED);
    return HWC2_ERROR_NONE;
}

int32_t getClientTargetSupportHook(hwc2_device_t* device, hwc2_display_t display, uint32_t width,
                                   uint32_t height, int32_t format, int32_t dataspace) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }
    if (dataspace != HAL_DATASPACE_UNKNOWN) {
        return HWC2_ERROR_UNSUPPORTED;
    }

    const auto& info = adapter.getInfo();
    return (info.width == width && info.height == height && info.format == format)
            ? HWC2_ERROR_NONE
            : HWC2_ERROR_UNSUPPORTED;
}

int32_t setClientTargetHook(hwc2_device_t* device, hwc2_display_t display, buffer_handle_t target,
                            int32_t acquireFence, int32_t dataspace, hwc_region_t /*damage*/) {
    if (acquireFence >= 0) {
        sync_wait(acquireFence, -1);
        close(acquireFence);
    }

    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }
    if (dataspace != HAL_DATASPACE_UNKNOWN) {
        return HWC2_ERROR_BAD_PARAMETER;
    }

    // no state change
    adapter.setBuffer(target);
    return HWC2_ERROR_NONE;
}

int32_t getDisplayConfigsHook(hwc2_device_t* device, hwc2_display_t display,
                              uint32_t* outNumConfigs, hwc2_config_t* outConfigs) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    if (outConfigs) {
        if (*outNumConfigs > 0) {
            outConfigs[0] = adapter.getConfigId();
            *outNumConfigs = 1;
        }
    } else {
        *outNumConfigs = 1;
    }

    return HWC2_ERROR_NONE;
}

int32_t getDisplayAttributeHook(hwc2_device_t* device, hwc2_display_t display, hwc2_config_t config,
                                int32_t attribute, int32_t* outValue) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }
    if (adapter.getConfigId() != config) {
        return HWC2_ERROR_BAD_CONFIG;
    }

    const auto& info = adapter.getInfo();
    switch (attribute) {
        case HWC2_ATTRIBUTE_WIDTH:
            *outValue = int32_t(info.width);
            break;
        case HWC2_ATTRIBUTE_HEIGHT:
            *outValue = int32_t(info.height);
            break;
        case HWC2_ATTRIBUTE_VSYNC_PERIOD:
            *outValue = int32_t(info.vsync_period_ns);
            break;
        case HWC2_ATTRIBUTE_DPI_X:
            *outValue = int32_t(info.xdpi_scaled);
            break;
        case HWC2_ATTRIBUTE_DPI_Y:
            *outValue = int32_t(info.ydpi_scaled);
            break;
        default:
            return HWC2_ERROR_BAD_PARAMETER;
    }

    return HWC2_ERROR_NONE;
}

int32_t getActiveConfigHook(hwc2_device_t* device, hwc2_display_t display,
                            hwc2_config_t* outConfig) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    *outConfig = adapter.getConfigId();
    return HWC2_ERROR_NONE;
}

int32_t setActiveConfigHook(hwc2_device_t* device, hwc2_display_t display, hwc2_config_t config) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }
    if (adapter.getConfigId() != config) {
        return HWC2_ERROR_BAD_CONFIG;
    }

    return HWC2_ERROR_NONE;
}

int32_t validateDisplayHook(hwc2_device_t* device, hwc2_display_t display, uint32_t* outNumTypes,
                            uint32_t* outNumRequests) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    const auto& dirtyLayers = adapter.getDirtyLayers();
    *outNumTypes = dirtyLayers.size();
    *outNumRequests = 0;

    if (*outNumTypes > 0) {
        adapter.setState(HWC2OnFbAdapter::State::VALIDATED_WITH_CHANGES);
        return HWC2_ERROR_HAS_CHANGES;
    } else {
        adapter.setState(HWC2OnFbAdapter::State::VALIDATED);
        return HWC2_ERROR_NONE;
    }
}

int32_t getChangedCompositionTypesHook(hwc2_device_t* device, hwc2_display_t display,
                                       uint32_t* outNumElements, hwc2_layer_t* outLayers,
                                       int32_t* outTypes) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }
    if (adapter.getState() == HWC2OnFbAdapter::State::MODIFIED) {
        return HWC2_ERROR_NOT_VALIDATED;
    }

    // request client composition for all layers
    const auto& dirtyLayers = adapter.getDirtyLayers();
    if (outLayers && outTypes) {
        *outNumElements = std::min(*outNumElements, uint32_t(dirtyLayers.size()));
        auto iter = dirtyLayers.cbegin();
        for (uint32_t i = 0; i < *outNumElements; i++) {
            outLayers[i] = *iter++;
            outTypes[i] = HWC2_COMPOSITION_CLIENT;
        }
    } else {
        *outNumElements = dirtyLayers.size();
    }

    return HWC2_ERROR_NONE;
}

int32_t getDisplayRequestsHook(hwc2_device_t* device, hwc2_display_t display,
                               int32_t* outDisplayRequests, uint32_t* outNumElements,
                               hwc2_layer_t* /*outLayers*/, int32_t* /*outLayerRequests*/) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }
    if (adapter.getState() == HWC2OnFbAdapter::State::MODIFIED) {
        return HWC2_ERROR_NOT_VALIDATED;
    }

    *outDisplayRequests = 0;
    *outNumElements = 0;
    return HWC2_ERROR_NONE;
}

int32_t acceptDisplayChangesHook(hwc2_device_t* device, hwc2_display_t display) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }
    if (adapter.getState() == HWC2OnFbAdapter::State::MODIFIED) {
        return HWC2_ERROR_NOT_VALIDATED;
    }

    adapter.clearDirtyLayers();
    adapter.setState(HWC2OnFbAdapter::State::VALIDATED);
    return HWC2_ERROR_NONE;
}

int32_t presentDisplayHook(hwc2_device_t* device, hwc2_display_t display,
                           int32_t* outPresentFence) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }
    if (adapter.getState() != HWC2OnFbAdapter::State::VALIDATED) {
        return HWC2_ERROR_NOT_VALIDATED;
    }

    adapter.postBuffer();
    *outPresentFence = -1;

    return HWC2_ERROR_NONE;
}

int32_t getReleaseFencesHook(hwc2_device_t* device, hwc2_display_t display,
                             uint32_t* outNumElements, hwc2_layer_t* /*outLayers*/,
                             int32_t* /*outFences*/) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    *outNumElements = 0;
    return HWC2_ERROR_NONE;
}

int32_t createLayerHook(hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t* outLayer) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    *outLayer = adapter.addLayer();
    adapter.setState(HWC2OnFbAdapter::State::MODIFIED);
    return HWC2_ERROR_NONE;
}

int32_t destroyLayerHook(hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    if (adapter.removeLayer(layer)) {
        adapter.setState(HWC2OnFbAdapter::State::MODIFIED);
        return HWC2_ERROR_NONE;
    } else {
        return HWC2_ERROR_BAD_LAYER;
    }
}

int32_t setCursorPositionHook(hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t /*layer*/,
                              int32_t /*x*/, int32_t /*y*/) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }

    // always an error
    return HWC2_ERROR_BAD_LAYER;
}

int32_t setLayerBufferHook(hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer,
                           buffer_handle_t /*buffer*/, int32_t acquireFence) {
    if (acquireFence >= 0) {
        sync_wait(acquireFence, -1);
        close(acquireFence);
    }

    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }
    if (!adapter.hasLayer(layer)) {
        return HWC2_ERROR_BAD_LAYER;
    }

    // no state change
    return HWC2_ERROR_NONE;
}

int32_t setLayerSurfaceDamageHook(hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer,
                                  hwc_region_t /*damage*/) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }
    if (!adapter.hasLayer(layer)) {
        return HWC2_ERROR_BAD_LAYER;
    }

    // no state change
    return HWC2_ERROR_NONE;
}

int32_t setLayerCompositionTypeHook(hwc2_device_t* device, hwc2_display_t display,
                                    hwc2_layer_t layer, int32_t type) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }
    if (!adapter.markLayerDirty(layer, type != HWC2_COMPOSITION_CLIENT)) {
        return HWC2_ERROR_BAD_LAYER;
    }

    adapter.setState(HWC2OnFbAdapter::State::MODIFIED);
    return HWC2_ERROR_NONE;
}

template <typename... Args>
int32_t setLayerStateHook(hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer,
                          Args... /*args*/) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    if (adapter.getDisplayId() != display) {
        return HWC2_ERROR_BAD_DISPLAY;
    }
    if (!adapter.hasLayer(layer)) {
        return HWC2_ERROR_BAD_LAYER;
    }

    adapter.setState(HWC2OnFbAdapter::State::MODIFIED);
    return HWC2_ERROR_NONE;
}

template <typename PFN, typename T>
static hwc2_function_pointer_t asFP(T function) {
    static_assert(std::is_same<PFN, T>::value, "Incompatible function pointer");
    return reinterpret_cast<hwc2_function_pointer_t>(function);
}

hwc2_function_pointer_t getFunctionHook(hwc2_device_t* /*device*/, int32_t descriptor) {
    switch (descriptor) {
        // global functions
        case HWC2_FUNCTION_DUMP:
            return asFP<HWC2_PFN_DUMP>(dumpHook);
        case HWC2_FUNCTION_REGISTER_CALLBACK:
            return asFP<HWC2_PFN_REGISTER_CALLBACK>(registerCallbackHook);

        // virtual display functions
        case HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT:
            return asFP<HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT>(getMaxVirtualDisplayCountHook);
        case HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY:
            return asFP<HWC2_PFN_CREATE_VIRTUAL_DISPLAY>(createVirtualDisplayHook);
        case HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY:
            return asFP<HWC2_PFN_DESTROY_VIRTUAL_DISPLAY>(destroyVirtualDisplayHook);
        case HWC2_FUNCTION_SET_OUTPUT_BUFFER:
            return asFP<HWC2_PFN_SET_OUTPUT_BUFFER>(setOutputBufferHook);

        // display functions
        case HWC2_FUNCTION_GET_DISPLAY_NAME:
            return asFP<HWC2_PFN_GET_DISPLAY_NAME>(getDisplayNameHook);
        case HWC2_FUNCTION_GET_DISPLAY_TYPE:
            return asFP<HWC2_PFN_GET_DISPLAY_TYPE>(getDisplayTypeHook);
        case HWC2_FUNCTION_GET_DOZE_SUPPORT:
            return asFP<HWC2_PFN_GET_DOZE_SUPPORT>(getDozeSupportHook);
        case HWC2_FUNCTION_GET_HDR_CAPABILITIES:
            return asFP<HWC2_PFN_GET_HDR_CAPABILITIES>(getHdrCapabilitiesHook);
        case HWC2_FUNCTION_SET_POWER_MODE:
            return asFP<HWC2_PFN_SET_POWER_MODE>(setPowerModeHook);
        case HWC2_FUNCTION_SET_VSYNC_ENABLED:
            return asFP<HWC2_PFN_SET_VSYNC_ENABLED>(setVsyncEnabledHook);
        case HWC2_FUNCTION_GET_COLOR_MODES:
            return asFP<HWC2_PFN_GET_COLOR_MODES>(getColorModesHook);
        case HWC2_FUNCTION_SET_COLOR_MODE:
            return asFP<HWC2_PFN_SET_COLOR_MODE>(setColorModeHook);
        case HWC2_FUNCTION_SET_COLOR_TRANSFORM:
            return asFP<HWC2_PFN_SET_COLOR_TRANSFORM>(setColorTransformHook);
        case HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT:
            return asFP<HWC2_PFN_GET_CLIENT_TARGET_SUPPORT>(getClientTargetSupportHook);
        case HWC2_FUNCTION_SET_CLIENT_TARGET:
            return asFP<HWC2_PFN_SET_CLIENT_TARGET>(setClientTargetHook);

        // config functions
        case HWC2_FUNCTION_GET_DISPLAY_CONFIGS:
            return asFP<HWC2_PFN_GET_DISPLAY_CONFIGS>(getDisplayConfigsHook);
        case HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE:
            return asFP<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>(getDisplayAttributeHook);
        case HWC2_FUNCTION_GET_ACTIVE_CONFIG:
            return asFP<HWC2_PFN_GET_ACTIVE_CONFIG>(getActiveConfigHook);
        case HWC2_FUNCTION_SET_ACTIVE_CONFIG:
            return asFP<HWC2_PFN_SET_ACTIVE_CONFIG>(setActiveConfigHook);

        // validate/present functions
        case HWC2_FUNCTION_VALIDATE_DISPLAY:
            return asFP<HWC2_PFN_VALIDATE_DISPLAY>(validateDisplayHook);
        case HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES:
            return asFP<HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES>(getChangedCompositionTypesHook);
        case HWC2_FUNCTION_GET_DISPLAY_REQUESTS:
            return asFP<HWC2_PFN_GET_DISPLAY_REQUESTS>(getDisplayRequestsHook);
        case HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES:
            return asFP<HWC2_PFN_ACCEPT_DISPLAY_CHANGES>(acceptDisplayChangesHook);
        case HWC2_FUNCTION_PRESENT_DISPLAY:
            return asFP<HWC2_PFN_PRESENT_DISPLAY>(presentDisplayHook);
        case HWC2_FUNCTION_GET_RELEASE_FENCES:
            return asFP<HWC2_PFN_GET_RELEASE_FENCES>(getReleaseFencesHook);

        // layer create/destroy
        case HWC2_FUNCTION_CREATE_LAYER:
            return asFP<HWC2_PFN_CREATE_LAYER>(createLayerHook);
        case HWC2_FUNCTION_DESTROY_LAYER:
            return asFP<HWC2_PFN_DESTROY_LAYER>(destroyLayerHook);

        // layer functions; validateDisplay not required
        case HWC2_FUNCTION_SET_CURSOR_POSITION:
            return asFP<HWC2_PFN_SET_CURSOR_POSITION>(setCursorPositionHook);
        case HWC2_FUNCTION_SET_LAYER_BUFFER:
            return asFP<HWC2_PFN_SET_LAYER_BUFFER>(setLayerBufferHook);
        case HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE:
            return asFP<HWC2_PFN_SET_LAYER_SURFACE_DAMAGE>(setLayerSurfaceDamageHook);

        // layer state functions; validateDisplay required
        case HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE:
            return asFP<HWC2_PFN_SET_LAYER_COMPOSITION_TYPE>(setLayerCompositionTypeHook);
        case HWC2_FUNCTION_SET_LAYER_BLEND_MODE:
            return asFP<HWC2_PFN_SET_LAYER_BLEND_MODE>(setLayerStateHook<int32_t>);
        case HWC2_FUNCTION_SET_LAYER_COLOR:
            return asFP<HWC2_PFN_SET_LAYER_COLOR>(setLayerStateHook<hwc_color_t>);
        case HWC2_FUNCTION_SET_LAYER_DATASPACE:
            return asFP<HWC2_PFN_SET_LAYER_DATASPACE>(setLayerStateHook<int32_t>);
        case HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME:
            return asFP<HWC2_PFN_SET_LAYER_DISPLAY_FRAME>(setLayerStateHook<hwc_rect_t>);
        case HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA:
            return asFP<HWC2_PFN_SET_LAYER_PLANE_ALPHA>(setLayerStateHook<float>);
        case HWC2_FUNCTION_SET_LAYER_SIDEBAND_STREAM:
            return asFP<HWC2_PFN_SET_LAYER_SIDEBAND_STREAM>(setLayerStateHook<buffer_handle_t>);
        case HWC2_FUNCTION_SET_LAYER_SOURCE_CROP:
            return asFP<HWC2_PFN_SET_LAYER_SOURCE_CROP>(setLayerStateHook<hwc_frect_t>);
        case HWC2_FUNCTION_SET_LAYER_TRANSFORM:
            return asFP<HWC2_PFN_SET_LAYER_TRANSFORM>(setLayerStateHook<int32_t>);
        case HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION:
            return asFP<HWC2_PFN_SET_LAYER_VISIBLE_REGION>(setLayerStateHook<hwc_region_t>);
        case HWC2_FUNCTION_SET_LAYER_Z_ORDER:
            return asFP<HWC2_PFN_SET_LAYER_Z_ORDER>(setLayerStateHook<uint32_t>);

        default:
            ALOGE("unknown function descriptor %d", descriptor);
            return nullptr;
    }
}

void getCapabilitiesHook(hwc2_device_t* device, uint32_t* outCount,
                         int32_t* outCapabilities) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    adapter.getCapabilities(outCount, outCapabilities);
}

int closeHook(hw_device_t* device) {
    auto& adapter = HWC2OnFbAdapter::cast(device);
    adapter.close();
    return 0;
}

} // anonymous namespace

HWC2OnFbAdapter::HWC2OnFbAdapter(framebuffer_device_t* fbDevice)
      : hwc2_device_t(), mFbDevice(fbDevice) {
    common.close = closeHook;
    hwc2_device::getCapabilities = getCapabilitiesHook;
    hwc2_device::getFunction = getFunctionHook;

    mFbInfo.name = "fbdev";
    mFbInfo.width = mFbDevice->width;
    mFbInfo.height = mFbDevice->height;
    mFbInfo.format = mFbDevice->format;
    mFbInfo.vsync_period_ns = int(1e9 / mFbDevice->fps);
    mFbInfo.xdpi_scaled = int(mFbDevice->xdpi * 1000.0f);
    mFbInfo.ydpi_scaled = int(mFbDevice->ydpi * 1000.0f);

    // Present fences aren't supported, always indicate PresentFenceIsNotReliable
    // for FB devices
    mCapabilities.insert(Capability::PresentFenceIsNotReliable);

    mVsyncThread.start(0, mFbInfo.vsync_period_ns);
}

HWC2OnFbAdapter& HWC2OnFbAdapter::cast(hw_device_t* device) {
    return *reinterpret_cast<HWC2OnFbAdapter*>(device);
}

HWC2OnFbAdapter& HWC2OnFbAdapter::cast(hwc2_device_t* device) {
    return *reinterpret_cast<HWC2OnFbAdapter*>(device);
}

hwc2_display_t HWC2OnFbAdapter::getDisplayId() {
    return 0;
}

hwc2_config_t HWC2OnFbAdapter::getConfigId() {
    return 0;
}

void HWC2OnFbAdapter::close() {
    mVsyncThread.stop();
    framebuffer_close(mFbDevice);
}

const HWC2OnFbAdapter::Info& HWC2OnFbAdapter::getInfo() const {
    return mFbInfo;
}

void HWC2OnFbAdapter::updateDebugString() {
    if (mFbDevice->common.version >= 1 && mFbDevice->dump) {
        char buffer[4096];
        mFbDevice->dump(mFbDevice, buffer, sizeof(buffer));
        buffer[sizeof(buffer) - 1] = '\0';

        mDebugString = buffer;
    }
}

const std::string& HWC2OnFbAdapter::getDebugString() const {
    return mDebugString;
}

void HWC2OnFbAdapter::setState(State state) {
    mState = state;
}

HWC2OnFbAdapter::State HWC2OnFbAdapter::getState() const {
    return mState;
}

hwc2_layer_t HWC2OnFbAdapter::addLayer() {
    hwc2_layer_t id = ++mNextLayerId;

    mLayers.insert(id);
    mDirtyLayers.insert(id);

    return id;
}

bool HWC2OnFbAdapter::removeLayer(hwc2_layer_t layer) {
    mDirtyLayers.erase(layer);
    return mLayers.erase(layer);
}

bool HWC2OnFbAdapter::hasLayer(hwc2_layer_t layer) const {
    return mLayers.count(layer) > 0;
}

bool HWC2OnFbAdapter::markLayerDirty(hwc2_layer_t layer, bool dirty) {
    if (mLayers.count(layer) == 0) {
        return false;
    }

    if (dirty) {
        mDirtyLayers.insert(layer);
    } else {
        mDirtyLayers.erase(layer);
    }

    return true;
}

const std::unordered_set<hwc2_layer_t>& HWC2OnFbAdapter::getDirtyLayers() const {
    return mDirtyLayers;
}

void HWC2OnFbAdapter::clearDirtyLayers() {
    mDirtyLayers.clear();
}

/*
 * For each frame, SurfaceFlinger
 *
 *  - peforms GLES composition
 *  - calls eglSwapBuffers
 *  - calls setClientTarget, which maps to setBuffer below
 *  - calls presentDisplay, which maps to postBuffer below
 *
 * setBuffer should be a good place to call compositionComplete.
 *
 * As for post, it
 *
 *  - schedules the buffer for presentation on the next vsync
 *  - locks the buffer and blocks all other users trying to lock it
 *
 * It does not give us a way to return a present fence, and we need to live
 * with that.  The implication is that, when we are double-buffered,
 * SurfaceFlinger assumes the front buffer is available for rendering again
 * immediately after the back buffer is posted.  The locking semantics
 * hopefully are strong enough that the rendering will be blocked.
 */
void HWC2OnFbAdapter::setBuffer(buffer_handle_t buffer) {
    if (mFbDevice->compositionComplete) {
        mFbDevice->compositionComplete(mFbDevice);
    }
    mBuffer = buffer;
}

bool HWC2OnFbAdapter::postBuffer() {
    int error = 0;
    if (mBuffer) {
        error = mFbDevice->post(mFbDevice, mBuffer);
    }

    return error == 0;
}

void HWC2OnFbAdapter::setVsyncCallback(HWC2_PFN_VSYNC callback, hwc2_callback_data_t data) {
    mVsyncThread.setCallback(callback, data);
}

void HWC2OnFbAdapter::enableVsync(bool enable) {
    mVsyncThread.enableCallback(enable);
}

void HWC2OnFbAdapter::getCapabilities(uint32_t* outCount,
                                      int32_t* outCapabilities) {
    if (outCapabilities == nullptr) {
        *outCount = mCapabilities.size();
        return;
    }

    auto capabilityIter = mCapabilities.cbegin();
    for (size_t written = 0; written < *outCount; ++written) {
        if (capabilityIter == mCapabilities.cend()) {
            return;
        }
        outCapabilities[written] = static_cast<int32_t>(*capabilityIter);
        ++capabilityIter;
    }
}

int64_t HWC2OnFbAdapter::VsyncThread::now() {
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);

    return int64_t(ts.tv_sec) * 1'000'000'000 + ts.tv_nsec;
}

bool HWC2OnFbAdapter::VsyncThread::sleepUntil(int64_t t) {
    struct timespec ts;
    ts.tv_sec = t / 1'000'000'000;
    ts.tv_nsec = t % 1'000'000'000;

    while (true) {
        int error = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &ts, nullptr);
        if (error) {
            if (error == EINTR) {
                continue;
            }
            return false;
        } else {
            return true;
        }
    }
}

void HWC2OnFbAdapter::VsyncThread::start(int64_t firstVsync, int64_t period) {
    mNextVsync = firstVsync;
    mPeriod = period;
    mStarted = true;
    mThread = std::thread(&VsyncThread::vsyncLoop, this);
}

void HWC2OnFbAdapter::VsyncThread::stop() {
    {
        std::lock_guard<std::mutex> lock(mMutex);
        mStarted = false;
    }
    mCondition.notify_all();
    mThread.join();
}

void HWC2OnFbAdapter::VsyncThread::setCallback(HWC2_PFN_VSYNC callback, hwc2_callback_data_t data) {
    std::lock_guard<std::mutex> lock(mMutex);
    mCallback = callback;
    mCallbackData = data;
}

void HWC2OnFbAdapter::VsyncThread::enableCallback(bool enable) {
    {
        std::lock_guard<std::mutex> lock(mMutex);
        mCallbackEnabled = enable;
    }
    mCondition.notify_all();
}

void HWC2OnFbAdapter::VsyncThread::vsyncLoop() {
    prctl(PR_SET_NAME, "VsyncThread", 0, 0, 0);

    std::unique_lock<std::mutex> lock(mMutex);
    if (!mStarted) {
        return;
    }

    while (true) {
        if (!mCallbackEnabled) {
            mCondition.wait(lock, [this] { return mCallbackEnabled || !mStarted; });
            if (!mStarted) {
                break;
            }
        }

        lock.unlock();

        // adjust mNextVsync if necessary
        int64_t t = now();
        if (mNextVsync < t) {
            int64_t n = (t - mNextVsync + mPeriod - 1) / mPeriod;
            mNextVsync += mPeriod * n;
        }
        bool fire = sleepUntil(mNextVsync);

        lock.lock();

        if (fire) {
            ALOGV("VsyncThread(%" PRId64 ")", mNextVsync);
            if (mCallback) {
                mCallback(mCallbackData, getDisplayId(), mNextVsync);
            }
            mNextVsync += mPeriod;
        }
    }
}

} // namespace android