blob: 280ec19a4c7f8b0c200ae489daa4621d8f8993ef [file] [log] [blame] [edit]
/*
* Copyright 2018 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.
*/
#pragma once
#include <aidl/android/hardware/graphics/composer3/DimmingStage.h>
#include <aidl/android/hardware/graphics/composer3/RenderIntent.h>
#include <iosfwd>
#include <math/mat4.h>
#include <renderengine/PrintMatrix.h>
#include <ui/DisplayId.h>
#include <ui/GraphicTypes.h>
#include <ui/Rect.h>
#include <ui/Region.h>
#include <ui/Transform.h>
#include <optional>
namespace android {
namespace renderengine {
// DisplaySettings contains the settings that are applicable when drawing all
// layers for a given display.
struct DisplaySettings {
// A string containing the name of the display, along with its id, if it has
// one.
std::string namePlusId;
// Rectangle describing the physical display. We will project from the
// logical clip onto this rectangle.
Rect physicalDisplay = Rect::INVALID_RECT;
// Rectangle bounded by the x,y- clipping planes in the logical display, so
// that the orthographic projection matrix can be computed. When
// constructing this matrix, z-coordinate bound are assumed to be at z=0 and
// z=1.
Rect clip = Rect::INVALID_RECT;
// Maximum luminance pulled from the display's HDR capabilities.
float maxLuminance = 1.0f;
// Current luminance of the display
float currentLuminanceNits = -1.f;
// Output dataspace that will be populated if wide color gamut is used, or
// DataSpace::UNKNOWN otherwise.
ui::Dataspace outputDataspace = ui::Dataspace::UNKNOWN;
// Additional color transform to apply after transforming to the output
// dataspace, in non-linear space.
mat4 colorTransform = mat4();
// If true, and colorTransform is non-identity, most client draw calls can
// ignore it. Some draws (e.g. screen decorations) may need it, though.
bool deviceHandlesColorTransform = false;
// An additional orientation flag to be applied after clipping the output.
// By way of example, this may be used for supporting fullscreen screenshot
// capture of a device in landscape while the buffer is in portrait
// orientation.
uint32_t orientation = ui::Transform::ROT_0;
// Target luminance of the display. -1f if unknown.
// All layers will be dimmed by (max(layer white points) / targetLuminanceNits).
// If the target luminance is unknown, then no display-level dimming occurs.
float targetLuminanceNits = -1.f;
// Configures when dimming should be applied for each layer.
aidl::android::hardware::graphics::composer3::DimmingStage dimmingStage =
aidl::android::hardware::graphics::composer3::DimmingStage::NONE;
// Configures the rendering intent of the output display. This is used for tonemapping.
aidl::android::hardware::graphics::composer3::RenderIntent renderIntent =
aidl::android::hardware::graphics::composer3::RenderIntent::TONE_MAP_COLORIMETRIC;
// Tonemapping strategy to use for each layer. This is only used for tonemapping HDR source
// content
enum class TonemapStrategy {
// Use a tonemapper defined by libtonemap. This may be OEM-defined as of Android 13, aka
// undefined.
// This is typically a global tonemapper, designed to match what is on screen.
Libtonemap,
// Use a local tonemapper. Because local tonemapping uses large intermediate allocations,
// this
// method is primarily recommended for infrequent rendering that does not need to exactly
// match
// pixels that are on-screen.
Local,
};
TonemapStrategy tonemapStrategy = TonemapStrategy::Libtonemap;
// For now, meaningful primarily when the TonemappingStrategy is Local
float targetHdrSdrRatio = 1.f;
};
static inline bool operator==(const DisplaySettings& lhs, const DisplaySettings& rhs) {
return lhs.namePlusId == rhs.namePlusId && lhs.physicalDisplay == rhs.physicalDisplay &&
lhs.clip == rhs.clip && lhs.maxLuminance == rhs.maxLuminance &&
lhs.currentLuminanceNits == rhs.currentLuminanceNits &&
lhs.outputDataspace == rhs.outputDataspace &&
lhs.colorTransform == rhs.colorTransform &&
lhs.deviceHandlesColorTransform == rhs.deviceHandlesColorTransform &&
lhs.orientation == rhs.orientation &&
lhs.targetLuminanceNits == rhs.targetLuminanceNits &&
lhs.dimmingStage == rhs.dimmingStage && lhs.renderIntent == rhs.renderIntent;
}
static const char* orientation_to_string(uint32_t orientation) {
switch (orientation) {
case ui::Transform::ROT_0:
return "ROT_0";
case ui::Transform::FLIP_H:
return "FLIP_H";
case ui::Transform::FLIP_V:
return "FLIP_V";
case ui::Transform::ROT_90:
return "ROT_90";
case ui::Transform::ROT_180:
return "ROT_180";
case ui::Transform::ROT_270:
return "ROT_270";
case ui::Transform::ROT_INVALID:
return "ROT_INVALID";
default:
ALOGE("invalid orientation!");
return "invalid orientation";
}
}
static inline void PrintTo(const DisplaySettings& settings, ::std::ostream* os) {
*os << "DisplaySettings {";
*os << "\n .display = " << settings.namePlusId;
*os << "\n .physicalDisplay = ";
PrintTo(settings.physicalDisplay, os);
*os << "\n .clip = ";
PrintTo(settings.clip, os);
*os << "\n .maxLuminance = " << settings.maxLuminance;
*os << "\n .currentLuminanceNits = " << settings.currentLuminanceNits;
*os << "\n .outputDataspace = ";
PrintTo(settings.outputDataspace, os);
*os << "\n .colorTransform = ";
PrintMatrix(settings.colorTransform, os);
*os << "\n .deviceHandlesColorTransform = " << settings.deviceHandlesColorTransform;
*os << "\n .orientation = " << orientation_to_string(settings.orientation);
*os << "\n .targetLuminanceNits = " << settings.targetLuminanceNits;
*os << "\n .dimmingStage = "
<< aidl::android::hardware::graphics::composer3::toString(settings.dimmingStage).c_str();
*os << "\n .renderIntent = "
<< aidl::android::hardware::graphics::composer3::toString(settings.renderIntent).c_str();
*os << "\n}";
}
} // namespace renderengine
} // namespace android