/*
* Copyright 2019 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 <apex/display.h>
#include <gui/SurfaceComposerClient.h>
#include <ui/DisplayMode.h>
#include <ui/DynamicDisplayInfo.h>
#include <ui/GraphicTypes.h>
#include <ui/PixelFormat.h>
#include <ui/StaticDisplayInfo.h>
#include <algorithm>
#include <optional>
#include <type_traits>
#include <vector>
namespace android::display::impl {
/**
* Implementation of ADisplayConfig
*/
struct DisplayConfigImpl {
/**
* The ID of the display configuration.
*/
size_t id;
/**
* The width in pixels of the display configuration.
*/
int32_t width{0};
/**
* The height in pixels of the display configuration.
*/
int32_t height{0};
/**
* The display density.
*/
float density{0};
/**
* The refresh rate of the display configuration, in frames per second.
*/
float fps{0.0};
/**
* The vsync offset at which surfaceflinger runs, in nanoseconds.
*/
int64_t sfOffset{0};
/**
* The vsync offset at which applications run, in nanoseconds.
*/
int64_t appOffset{0};
};
// DisplayConfigImpl allocation is not managed through C++ memory apis, so
// preventing calling the destructor here.
static_assert(std::is_trivially_destructible<DisplayConfigImpl>::value);
/**
* Implementation of ADisplay
*/
struct DisplayImpl {
/**
* A physical display ID, unique to this display.
*/
PhysicalDisplayId id;
/**
* The type of the display, i.e. whether it is an internal or external
* display.
*/
ADisplayType type;
/**
* The preferred WCG dataspace
*/
ADataSpace wcgDataspace;
/**
* The preferred WCG pixel format
*/
AHardwareBuffer_Format wcgPixelFormat;
/**
* Number of supported configs
*/
size_t numConfigs;
/**
* Set of supported configs by this display.
*/
DisplayConfigImpl* configs;
};
// DisplayImpl allocation is not managed through C++ memory apis, so
// preventing calling the destructor here.
static_assert(std::is_trivially_destructible<DisplayImpl>::value);
} // namespace android::display::impl
using namespace android;
using namespace android::display::impl;
#define CHECK_NOT_NULL(name) \
LOG_ALWAYS_FATAL_IF(name == nullptr, "nullptr passed as " #name " argument");
namespace {
sp<IBinder> getToken(ADisplay* display) {
DisplayImpl* impl = reinterpret_cast<DisplayImpl*>(display);
return SurfaceComposerClient::getPhysicalDisplayToken(impl->id);
}
} // namespace
namespace android {
int ADisplay_acquirePhysicalDisplays(ADisplay*** outDisplays) {
const std::vector<PhysicalDisplayId> ids = SurfaceComposerClient::getPhysicalDisplayIds();
const size_t size = ids.size();
if (size == 0) {
return NO_INIT;
}
std::vector<DisplayConfigImpl> modesPerDisplay[size];
int numModes = 0;
for (int i = 0; i < size; ++i) {
const sp<IBinder> token = SurfaceComposerClient::getPhysicalDisplayToken(ids[i]);
ui::StaticDisplayInfo staticInfo;
if (const status_t status = SurfaceComposerClient::getStaticDisplayInfo(token, &staticInfo);
status != OK) {
return status;
}
ui::DynamicDisplayInfo dynamicInfo;
if (const status_t status =
SurfaceComposerClient::getDynamicDisplayInfo(token, &dynamicInfo);
status != OK) {
return status;
}
const auto& modes = dynamicInfo.supportedDisplayModes;
if (modes.empty()) {
return NO_INIT;
}
numModes += modes.size();
modesPerDisplay[i].reserve(modes.size());
for (int j = 0; j < modes.size(); ++j) {
const ui::DisplayMode& mode = modes[j];
modesPerDisplay[i].emplace_back(
DisplayConfigImpl{static_cast<size_t>(mode.id), mode.resolution.getWidth(),
mode.resolution.getHeight(), staticInfo.density,
mode.refreshRate, mode.sfVsyncOffset, mode.appVsyncOffset});
}
}
const std::optional<PhysicalDisplayId> internalId =
SurfaceComposerClient::getInternalDisplayId();
ui::Dataspace defaultDataspace;
ui::PixelFormat defaultPixelFormat;
ui::Dataspace wcgDataspace;
ui::PixelFormat wcgPixelFormat;
const status_t status =
SurfaceComposerClient::getCompositionPreference(&defaultDataspace, &defaultPixelFormat,
&wcgDataspace, &wcgPixelFormat);
if (status != NO_ERROR) {
return status;
}
// Here we allocate all our required memory in one block. The layout is as
// follows:
// ------------------------------------------------------------
// | DisplayImpl pointers | DisplayImpls | DisplayConfigImpls |
// ------------------------------------------------------------
//
// The caller will be given a DisplayImpl** which points to the beginning of
// the block of DisplayImpl pointers.
// Each DisplayImpl* points to a DisplayImpl in the second block.
// Each DisplayImpl contains a DisplayConfigImpl*, which points to a
// contiguous block of DisplayConfigImpls specific to that display.
DisplayImpl** const impls = reinterpret_cast<DisplayImpl**>(
malloc((sizeof(DisplayImpl) + sizeof(DisplayImpl*)) * size +
sizeof(DisplayConfigImpl) * numModes));
DisplayImpl* const displayData = reinterpret_cast<DisplayImpl*>(impls + size);
DisplayConfigImpl* configData = reinterpret_cast<DisplayConfigImpl*>(displayData + size);
for (size_t i = 0; i < size; ++i) {
const PhysicalDisplayId id = ids[i];
const ADisplayType type = (internalId == id) ? ADisplayType::DISPLAY_TYPE_INTERNAL
: ADisplayType::DISPLAY_TYPE_EXTERNAL;
const std::vector<DisplayConfigImpl>& configs = modesPerDisplay[i];
memcpy(configData, configs.data(), sizeof(DisplayConfigImpl) * configs.size());
displayData[i] = DisplayImpl{id,
type,
static_cast<ADataSpace>(wcgDataspace),
static_cast<AHardwareBuffer_Format>(wcgPixelFormat),
configs.size(),
configData};
impls[i] = displayData + i;
// Advance the configData pointer so that future configs are written to
// the correct display.
configData += configs.size();
}
*outDisplays = reinterpret_cast<ADisplay**>(impls);
return size;
}
void ADisplay_release(ADisplay** displays) {
if (displays == nullptr) {
return;
}
free(displays);
}
float ADisplay_getMaxSupportedFps(ADisplay* display) {
CHECK_NOT_NULL(display);
DisplayImpl* impl = reinterpret_cast<DisplayImpl*>(display);
float maxFps = 0.0;
for (int i = 0; i < impl->numConfigs; ++i) {
maxFps = std::max(maxFps, impl->configs[i].fps);
}
return maxFps;
}
ADisplayType ADisplay_getDisplayType(ADisplay* display) {
CHECK_NOT_NULL(display);
return reinterpret_cast<DisplayImpl*>(display)->type;
}
void ADisplay_getPreferredWideColorFormat(ADisplay* display, ADataSpace* outDataspace,
AHardwareBuffer_Format* outPixelFormat) {
CHECK_NOT_NULL(display);
CHECK_NOT_NULL(outDataspace);
CHECK_NOT_NULL(outPixelFormat);
DisplayImpl* impl = reinterpret_cast<DisplayImpl*>(display);
*outDataspace = impl->wcgDataspace;
*outPixelFormat = impl->wcgPixelFormat;
}
int ADisplay_getCurrentConfig(ADisplay* display, ADisplayConfig** outConfig) {
CHECK_NOT_NULL(display);
sp<IBinder> token = getToken(display);
ui::DynamicDisplayInfo info;
if (const auto status = SurfaceComposerClient::getDynamicDisplayInfo(token, &info);
status != OK) {
return status;
}
DisplayImpl* impl = reinterpret_cast<DisplayImpl*>(display);
for (size_t i = 0; i < impl->numConfigs; i++) {
auto* config = impl->configs + i;
if (config->id == info.activeDisplayModeId) {
*outConfig = reinterpret_cast<ADisplayConfig*>(config);
return OK;
}
}
return NAME_NOT_FOUND;
}
float ADisplayConfig_getDensity(ADisplayConfig* config) {
CHECK_NOT_NULL(config);
return reinterpret_cast<DisplayConfigImpl*>(config)->density;
}
int32_t ADisplayConfig_getWidth(ADisplayConfig* config) {
CHECK_NOT_NULL(config);
return reinterpret_cast<DisplayConfigImpl*>(config)->width;
}
int32_t ADisplayConfig_getHeight(ADisplayConfig* config) {
CHECK_NOT_NULL(config);
return reinterpret_cast<DisplayConfigImpl*>(config)->height;
}
float ADisplayConfig_getFps(ADisplayConfig* config) {
CHECK_NOT_NULL(config);
return reinterpret_cast<DisplayConfigImpl*>(config)->fps;
}
int64_t ADisplayConfig_getCompositorOffsetNanos(ADisplayConfig* config) {
CHECK_NOT_NULL(config);
return reinterpret_cast<DisplayConfigImpl*>(config)->sfOffset;
}
int64_t ADisplayConfig_getAppVsyncOffsetNanos(ADisplayConfig* config) {
CHECK_NOT_NULL(config);
return reinterpret_cast<DisplayConfigImpl*>(config)->appOffset;
}
} // namespace android