#include "hardware_composer.h"
#include <binder/IServiceManager.h>
#include <cutils/properties.h>
#include <cutils/sched_policy.h>
#include <fcntl.h>
#include <log/log.h>
#include <poll.h>
#include <stdint.h>
#include <sync/sync.h>
#include <sys/eventfd.h>
#include <sys/prctl.h>
#include <sys/resource.h>
#include <sys/system_properties.h>
#include <sys/timerfd.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#include <utils/Trace.h>
#include <algorithm>
#include <chrono>
#include <functional>
#include <map>
#include <sstream>
#include <string>
#include <tuple>
#include <dvr/dvr_display_types.h>
#include <dvr/performance_client_api.h>
#include <private/dvr/clock_ns.h>
#include <private/dvr/ion_buffer.h>
using android::hardware::Return;
using android::hardware::Void;
using android::pdx::ErrorStatus;
using android::pdx::LocalHandle;
using android::pdx::Status;
using android::pdx::rpc::EmptyVariant;
using android::pdx::rpc::IfAnyOf;
using namespace std::chrono_literals;
namespace android {
namespace dvr {
namespace {
const char kDvrPerformanceProperty[] = "sys.dvr.performance";
const char kDvrStandaloneProperty[] = "ro.boot.vr";
const char kRightEyeOffsetProperty[] = "dvr.right_eye_offset_ns";
const char kUseExternalDisplayProperty[] = "persist.vr.use_external_display";
// Surface flinger uses "VSYNC-sf" and "VSYNC-app" for its version of these
// events. Name ours similarly.
const char kVsyncTraceEventName[] = "VSYNC-vrflinger";
// How long to wait after boot finishes before we turn the display off.
constexpr int kBootFinishedDisplayOffTimeoutSec = 10;
constexpr int kDefaultDisplayWidth = 1920;
constexpr int kDefaultDisplayHeight = 1080;
constexpr int64_t kDefaultVsyncPeriodNs = 16666667;
// Hardware composer reports dpi as dots per thousand inches (dpi * 1000).
constexpr int kDefaultDpi = 400000;
// Get time offset from a vsync to when the pose for that vsync should be
// predicted out to. For example, if scanout gets halfway through the frame
// at the halfway point between vsyncs, then this could be half the period.
// With global shutter displays, this should be changed to the offset to when
// illumination begins. Low persistence adds a frame of latency, so we predict
// to the center of the next frame.
inline int64_t GetPosePredictionTimeOffset(int64_t vsync_period_ns) {
return (vsync_period_ns * 150) / 100;
}
// Attempts to set the scheduler class and partiton for the current thread.
// Returns true on success or false on failure.
bool SetThreadPolicy(const std::string& scheduler_class,
const std::string& partition) {
int error = dvrSetSchedulerClass(0, scheduler_class.c_str());
if (error < 0) {
ALOGE(
"SetThreadPolicy: Failed to set scheduler class \"%s\" for "
"thread_id=%d: %s",
scheduler_class.c_str(), gettid(), strerror(-error));
return false;
}
error = dvrSetCpuPartition(0, partition.c_str());
if (error < 0) {
ALOGE(
"SetThreadPolicy: Failed to set cpu partiton \"%s\" for thread_id=%d: "
"%s",
partition.c_str(), gettid(), strerror(-error));
return false;
}
return true;
}
// Utility to generate scoped tracers with arguments.
// TODO(eieio): Move/merge this into utils/Trace.h?
class TraceArgs {
public:
template <typename... Args>
explicit TraceArgs(const char* format, Args&&... args) {
std::array<char, 1024> buffer;
snprintf(buffer.data(), buffer.size(), format, std::forward<Args>(args)...);
atrace_begin(ATRACE_TAG, buffer.data());
}
~TraceArgs() { atrace_end(ATRACE_TAG); }
private:
TraceArgs(const TraceArgs&) = delete;
void operator=(const TraceArgs&) = delete;
};
// Macro to define a scoped tracer with arguments. Uses PASTE(x, y) macro
// defined in utils/Trace.h.
#define TRACE_FORMAT(format, ...) \
TraceArgs PASTE(__tracer, __LINE__) { format, ##__VA_ARGS__ }
// Returns "primary" or "external". Useful for writing more readable logs.
const char* GetDisplayName(bool is_primary) {
return is_primary ? "primary" : "external";
}
} // anonymous namespace
HardwareComposer::HardwareComposer()
: initialized_(false), request_display_callback_(nullptr) {}
HardwareComposer::~HardwareComposer(void) {
UpdatePostThreadState(PostThreadState::Quit, true);
if (post_thread_.joinable())
post_thread_.join();
composer_callback_->SetVsyncService(nullptr);
}
bool HardwareComposer::Initialize(
Hwc2::Composer* composer, hwc2_display_t primary_display_id,
RequestDisplayCallback request_display_callback) {
if (initialized_) {
ALOGE("HardwareComposer::Initialize: already initialized.");
return false;
}
is_standalone_device_ = property_get_bool(kDvrStandaloneProperty, false);
request_display_callback_ = request_display_callback;
primary_display_ = GetDisplayParams(composer, primary_display_id, true);
vsync_service_ = new VsyncService;
sp<IServiceManager> sm(defaultServiceManager());
auto result = sm->addService(String16(VsyncService::GetServiceName()),
vsync_service_, false);
LOG_ALWAYS_FATAL_IF(result != android::OK,
"addService(%s) failed", VsyncService::GetServiceName());
post_thread_event_fd_.Reset(eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK));
LOG_ALWAYS_FATAL_IF(
!post_thread_event_fd_,
"HardwareComposer: Failed to create interrupt event fd : %s",
strerror(errno));
post_thread_ = std::thread(&HardwareComposer::PostThread, this);
initialized_ = true;
return initialized_;
}
void HardwareComposer::Enable() {
UpdatePostThreadState(PostThreadState::Suspended, false);
}
void HardwareComposer::Disable() {
UpdatePostThreadState(PostThreadState::Suspended, true);
std::unique_lock<std::mutex> lock(post_thread_mutex_);
post_thread_ready_.wait(lock, [this] {
return !post_thread_resumed_;
});
}
void HardwareComposer::OnBootFinished() {
std::lock_guard<std::mutex> lock(post_thread_mutex_);
if (boot_finished_)
return;
boot_finished_ = true;
post_thread_wait_.notify_one();
if (is_standalone_device_)
request_display_callback_(true);
}
// Update the post thread quiescent state based on idle and suspended inputs.
void HardwareComposer::UpdatePostThreadState(PostThreadStateType state,
bool suspend) {
std::unique_lock<std::mutex> lock(post_thread_mutex_);
// Update the votes in the state variable before evaluating the effective
// quiescent state. Any bits set in post_thread_state_ indicate that the post
// thread should be suspended.
if (suspend) {
post_thread_state_ |= state;
} else {
post_thread_state_ &= ~state;
}
const bool quit = post_thread_state_ & PostThreadState::Quit;
const bool effective_suspend = post_thread_state_ != PostThreadState::Active;
if (quit) {
post_thread_quiescent_ = true;
eventfd_write(post_thread_event_fd_.Get(), 1);
post_thread_wait_.notify_one();
} else if (effective_suspend && !post_thread_quiescent_) {
post_thread_quiescent_ = true;
eventfd_write(post_thread_event_fd_.Get(), 1);
} else if (!effective_suspend && post_thread_quiescent_) {
post_thread_quiescent_ = false;
eventfd_t value;
eventfd_read(post_thread_event_fd_.Get(), &value);
post_thread_wait_.notify_one();
}
}
void HardwareComposer::CreateComposer() {
if (composer_)
return;
composer_.reset(new Hwc2::impl::Composer("default"));
composer_callback_ = new ComposerCallback;
composer_->registerCallback(composer_callback_);
LOG_ALWAYS_FATAL_IF(!composer_callback_->GotFirstHotplug(),
"Registered composer callback but didn't get hotplug for primary"
" display");
composer_callback_->SetVsyncService(vsync_service_);
}
void HardwareComposer::OnPostThreadResumed() {
ALOGI("OnPostThreadResumed");
EnableDisplay(*target_display_, true);
// Trigger target-specific performance mode change.
property_set(kDvrPerformanceProperty, "performance");
}
void HardwareComposer::OnPostThreadPaused() {
ALOGI("OnPostThreadPaused");
retire_fence_fds_.clear();
layers_.clear();
// Phones create a new composer client on resume and destroy it on pause.
// Standalones only create the composer client once and then use SetPowerMode
// to control the screen on pause/resume.
if (!is_standalone_device_) {
if (composer_callback_ != nullptr) {
composer_callback_->SetVsyncService(nullptr);
composer_callback_ = nullptr;
}
composer_.reset(nullptr);
} else {
EnableDisplay(*target_display_, false);
}
// Trigger target-specific performance mode change.
property_set(kDvrPerformanceProperty, "idle");
}
bool HardwareComposer::PostThreadCondWait(std::unique_lock<std::mutex>& lock,
int timeout_sec,
const std::function<bool()>& pred) {
auto pred_with_quit = [&] {
return pred() || (post_thread_state_ & PostThreadState::Quit);
};
if (timeout_sec >= 0) {
post_thread_wait_.wait_for(lock, std::chrono::seconds(timeout_sec),
pred_with_quit);
} else {
post_thread_wait_.wait(lock, pred_with_quit);
}
if (post_thread_state_ & PostThreadState::Quit) {
ALOGI("HardwareComposer::PostThread: Quitting.");
return true;
}
return false;
}
HWC::Error HardwareComposer::Validate(hwc2_display_t display) {
uint32_t num_types;
uint32_t num_requests;
HWC::Error error =
composer_->validateDisplay(display, &num_types, &num_requests);
if (error == HWC2_ERROR_HAS_CHANGES) {
ALOGE("Hardware composer has requested composition changes, "
"which we don't support.");
// Accept the changes anyway and see if we can get something on the screen.
error = composer_->acceptDisplayChanges(display);
}
return error;
}
bool HardwareComposer::EnableVsync(const DisplayParams& display, bool enabled) {
HWC::Error error = composer_->setVsyncEnabled(display.id,
(Hwc2::IComposerClient::Vsync)(enabled ? HWC2_VSYNC_ENABLE
: HWC2_VSYNC_DISABLE));
if (error != HWC::Error::None) {
ALOGE("Error attempting to %s vsync on %s display: %s",
enabled ? "enable" : "disable", GetDisplayName(display.is_primary),
error.to_string().c_str());
}
return error == HWC::Error::None;
}
bool HardwareComposer::SetPowerMode(const DisplayParams& display, bool active) {
ALOGI("Turning %s display %s", GetDisplayName(display.is_primary),
active ? "on" : "off");
HWC::PowerMode power_mode = active ? HWC::PowerMode::On : HWC::PowerMode::Off;
HWC::Error error = composer_->setPowerMode(display.id,
power_mode.cast<Hwc2::IComposerClient::PowerMode>());
if (error != HWC::Error::None) {
ALOGE("Error attempting to turn %s display %s: %s",
GetDisplayName(display.is_primary), active ? "on" : "off",
error.to_string().c_str());
}
return error == HWC::Error::None;
}
bool HardwareComposer::EnableDisplay(const DisplayParams& display,
bool enabled) {
bool power_result;
bool vsync_result;
// When turning a display on, we set the power state then set vsync. When
// turning a display off we do it in the opposite order.
if (enabled) {
power_result = SetPowerMode(display, enabled);
vsync_result = EnableVsync(display, enabled);
} else {
vsync_result = EnableVsync(display, enabled);
power_result = SetPowerMode(display, enabled);
}
return power_result && vsync_result;
}
HWC::Error HardwareComposer::Present(hwc2_display_t display) {
int32_t present_fence;
HWC::Error error = composer_->presentDisplay(display, &present_fence);
// According to the documentation, this fence is signaled at the time of
// vsync/DMA for physical displays.
if (error == HWC::Error::None) {
retire_fence_fds_.emplace_back(present_fence);
} else {
ATRACE_INT("HardwareComposer: PresentResult", error);
}
return error;
}
DisplayParams HardwareComposer::GetDisplayParams(
Hwc2::Composer* composer, hwc2_display_t display, bool is_primary) {
DisplayParams params;
params.id = display;
params.is_primary = is_primary;
Hwc2::Config config;
HWC::Error error = composer->getActiveConfig(display, &config);
if (error == HWC::Error::None) {
auto get_attr = [&](hwc2_attribute_t attr, const char* attr_name)
-> std::optional<int32_t> {
int32_t val;
HWC::Error error = composer->getDisplayAttribute(
display, config, (Hwc2::IComposerClient::Attribute)attr, &val);
if (error != HWC::Error::None) {
ALOGE("Failed to get %s display attr %s: %s",
GetDisplayName(is_primary), attr_name,
error.to_string().c_str());
return std::nullopt;
}
return val;
};
auto width = get_attr(HWC2_ATTRIBUTE_WIDTH, "width");
auto height = get_attr(HWC2_ATTRIBUTE_HEIGHT, "height");
if (width && height) {
params.width = *width;
params.height = *height;
} else {
ALOGI("Failed to get width and/or height for %s display. Using default"
" size %dx%d.", GetDisplayName(is_primary), kDefaultDisplayWidth,
kDefaultDisplayHeight);
params.width = kDefaultDisplayWidth;
params.height = kDefaultDisplayHeight;
}
auto vsync_period = get_attr(HWC2_ATTRIBUTE_VSYNC_PERIOD, "vsync period");
if (vsync_period) {
params.vsync_period_ns = *vsync_period;
} else {
ALOGI("Failed to get vsync period for %s display. Using default vsync"
" period %.2fms", GetDisplayName(is_primary),
static_cast<float>(kDefaultVsyncPeriodNs) / 1000000);
params.vsync_period_ns = kDefaultVsyncPeriodNs;
}
auto dpi_x = get_attr(HWC2_ATTRIBUTE_DPI_X, "DPI X");
auto dpi_y = get_attr(HWC2_ATTRIBUTE_DPI_Y, "DPI Y");
if (dpi_x && dpi_y) {
params.dpi.x = *dpi_x;
params.dpi.y = *dpi_y;
} else {
ALOGI("Failed to get dpi_x and/or dpi_y for %s display. Using default"
" dpi %d.", GetDisplayName(is_primary), kDefaultDpi);
params.dpi.x = kDefaultDpi;
params.dpi.y = kDefaultDpi;
}
} else {
ALOGE("HardwareComposer: Failed to get current %s display config: %d."
" Using default display values.",
GetDisplayName(is_primary), error.value);
params.width = kDefaultDisplayWidth;
params.height = kDefaultDisplayHeight;
params.dpi.x = kDefaultDpi;
params.dpi.y = kDefaultDpi;
params.vsync_period_ns = kDefaultVsyncPeriodNs;
}
ALOGI(
"HardwareComposer: %s display attributes: width=%d height=%d "
"vsync_period_ns=%d DPI=%dx%d",
GetDisplayName(is_primary),
params.width,
params.height,
params.vsync_period_ns,
params.dpi.x,
params.dpi.y);
return params;
}
std::string HardwareComposer::Dump() {
std::unique_lock<std::mutex> lock(post_thread_mutex_);
std::ostringstream stream;
auto print_display_metrics = [&](const DisplayParams& params) {
stream << GetDisplayName(params.is_primary)
<< " display metrics: " << params.width << "x"
<< params.height << " " << (params.dpi.x / 1000.0)
<< "x" << (params.dpi.y / 1000.0) << " dpi @ "
<< (1000000000.0 / params.vsync_period_ns) << " Hz"
<< std::endl;
};
print_display_metrics(primary_display_);
if (external_display_)
print_display_metrics(*external_display_);
stream << "Post thread resumed: " << post_thread_resumed_ << std::endl;
stream << "Active layers: " << layers_.size() << std::endl;
stream << std::endl;
for (size_t i = 0; i < layers_.size(); i++) {
stream << "Layer " << i << ":";
stream << " type=" << layers_[i].GetCompositionType().to_string();
stream << " surface_id=" << layers_[i].GetSurfaceId();
stream << " buffer_id=" << layers_[i].GetBufferId();
stream << std::endl;
}
stream << std::endl;
if (post_thread_resumed_) {
stream << "Hardware Composer Debug Info:" << std::endl;
stream << composer_->dumpDebugInfo();
}
return stream.str();
}
void HardwareComposer::PostLayers(hwc2_display_t display) {
ATRACE_NAME("HardwareComposer::PostLayers");
// Setup the hardware composer layers with current buffers.
for (auto& layer : layers_) {
layer.Prepare();
}
// Now that we have taken in a frame from the application, we have a chance
// to drop the frame before passing the frame along to HWC.
// If the display driver has become backed up, we detect it here and then
// react by skipping this frame to catch up latency.
while (!retire_fence_fds_.empty() &&
(!retire_fence_fds_.front() ||
sync_wait(retire_fence_fds_.front().Get(), 0) == 0)) {
// There are only 2 fences in here, no performance problem to shift the
// array of ints.
retire_fence_fds_.erase(retire_fence_fds_.begin());
}
const bool is_fence_pending = static_cast<int32_t>(retire_fence_fds_.size()) >
post_thread_config_.allowed_pending_fence_count;
if (is_fence_pending) {
ATRACE_INT("frame_skip_count", ++frame_skip_count_);
ALOGW_IF(is_fence_pending,
"Warning: dropping a frame to catch up with HWC (pending = %zd)",
retire_fence_fds_.size());
for (auto& layer : layers_) {
layer.Drop();
}
return;
} else {
// Make the transition more obvious in systrace when the frame skip happens
// above.
ATRACE_INT("frame_skip_count", 0);
}
#if TRACE > 1
for (size_t i = 0; i < layers_.size(); i++) {
ALOGI("HardwareComposer::PostLayers: layer=%zu buffer_id=%d composition=%s",
i, layers_[i].GetBufferId(),
layers_[i].GetCompositionType().to_string().c_str());
}
#endif
HWC::Error error = Validate(display);
if (error != HWC::Error::None) {
ALOGE("HardwareComposer::PostLayers: Validate failed: %s display=%" PRIu64,
error.to_string().c_str(), display);
return;
}
error = Present(display);
if (error != HWC::Error::None) {
ALOGE("HardwareComposer::PostLayers: Present failed: %s",
error.to_string().c_str());
return;
}
std::vector<Hwc2::Layer> out_layers;
std::vector<int> out_fences;
error = composer_->getReleaseFences(display,
&out_layers, &out_fences);
ALOGE_IF(error != HWC::Error::None,
"HardwareComposer::PostLayers: Failed to get release fences: %s",
error.to_string().c_str());
// Perform post-frame bookkeeping.
uint32_t num_elements = out_layers.size();
for (size_t i = 0; i < num_elements; ++i) {
for (auto& layer : layers_) {
if (layer.GetLayerHandle() == out_layers[i]) {
layer.Finish(out_fences[i]);
}
}
}
}
void HardwareComposer::SetDisplaySurfaces(
std::vector<std::shared_ptr<DirectDisplaySurface>> surfaces) {
ALOGI("HardwareComposer::SetDisplaySurfaces: surface count=%zd",
surfaces.size());
const bool display_idle = surfaces.size() == 0;
{
std::unique_lock<std::mutex> lock(post_thread_mutex_);
surfaces_ = std::move(surfaces);
surfaces_changed_ = true;
}
if (request_display_callback_ && !is_standalone_device_)
request_display_callback_(!display_idle);
// Set idle state based on whether there are any surfaces to handle.
UpdatePostThreadState(PostThreadState::Idle, display_idle);
}
int HardwareComposer::OnNewGlobalBuffer(DvrGlobalBufferKey key,
IonBuffer& ion_buffer) {
if (key == DvrGlobalBuffers::kVsyncBuffer) {
vsync_ring_ = std::make_unique<CPUMappedBroadcastRing<DvrVsyncRing>>(
&ion_buffer, CPUUsageMode::WRITE_OFTEN);
if (vsync_ring_->IsMapped() == false) {
return -EPERM;
}
}
if (key == DvrGlobalBuffers::kVrFlingerConfigBufferKey) {
return MapConfigBuffer(ion_buffer);
}
return 0;
}
void HardwareComposer::OnDeletedGlobalBuffer(DvrGlobalBufferKey key) {
if (key == DvrGlobalBuffers::kVrFlingerConfigBufferKey) {
ConfigBufferDeleted();
}
}
int HardwareComposer::MapConfigBuffer(IonBuffer& ion_buffer) {
std::lock_guard<std::mutex> lock(shared_config_mutex_);
shared_config_ring_ = DvrConfigRing();
if (ion_buffer.width() < DvrConfigRing::MemorySize()) {
ALOGE("HardwareComposer::MapConfigBuffer: invalid buffer size.");
return -EINVAL;
}
void* buffer_base = 0;
int result = ion_buffer.Lock(ion_buffer.usage(), 0, 0, ion_buffer.width(),
ion_buffer.height(), &buffer_base);
if (result != 0) {
ALOGE(
"HardwareComposer::MapConfigBuffer: Failed to map vrflinger config "
"buffer.");
return -EPERM;
}
shared_config_ring_ = DvrConfigRing::Create(buffer_base, ion_buffer.width());
ion_buffer.Unlock();
return 0;
}
void HardwareComposer::ConfigBufferDeleted() {
std::lock_guard<std::mutex> lock(shared_config_mutex_);
shared_config_ring_ = DvrConfigRing();
}
void HardwareComposer::UpdateConfigBuffer() {
std::lock_guard<std::mutex> lock(shared_config_mutex_);
if (!shared_config_ring_.is_valid())
return;
// Copy from latest record in shared_config_ring_ to local copy.
DvrConfig record;
if (shared_config_ring_.GetNewest(&shared_config_ring_sequence_, &record)) {
ALOGI("DvrConfig updated: sequence %u, post offset %d",
shared_config_ring_sequence_, record.frame_post_offset_ns);
++shared_config_ring_sequence_;
post_thread_config_ = record;
}
}
int HardwareComposer::PostThreadPollInterruptible(
const pdx::LocalHandle& event_fd, int requested_events, int timeout_ms) {
pollfd pfd[2] = {
{
.fd = event_fd.Get(),
.events = static_cast<short>(requested_events),
.revents = 0,
},
{
.fd = post_thread_event_fd_.Get(),
.events = POLLPRI | POLLIN,
.revents = 0,
},
};
int ret, error;
do {
ret = poll(pfd, 2, timeout_ms);
error = errno;
ALOGW_IF(ret < 0,
"HardwareComposer::PostThreadPollInterruptible: Error during "
"poll(): %s (%d)",
strerror(error), error);
} while (ret < 0 && error == EINTR);
if (ret < 0) {
return -error;
} else if (ret == 0) {
return -ETIMEDOUT;
} else if (pfd[0].revents != 0) {
return 0;
} else if (pfd[1].revents != 0) {
ALOGI("VrHwcPost thread interrupted: revents=%x", pfd[1].revents);
return kPostThreadInterrupted;
} else {
return 0;
}
}
// Sleep until the next predicted vsync, returning the predicted vsync
// timestamp.
Status<int64_t> HardwareComposer::WaitForPredictedVSync() {
const int64_t predicted_vsync_time = last_vsync_timestamp_ +
(target_display_->vsync_period_ns * vsync_prediction_interval_);
const int error = SleepUntil(predicted_vsync_time);
if (error < 0) {
ALOGE("HardwareComposer::WaifForVSync:: Failed to sleep: %s",
strerror(-error));
return error;
}
return {predicted_vsync_time};
}
int HardwareComposer::SleepUntil(int64_t wakeup_timestamp) {
const int timer_fd = vsync_sleep_timer_fd_.Get();
const itimerspec wakeup_itimerspec = {
.it_interval = {.tv_sec = 0, .tv_nsec = 0},
.it_value = NsToTimespec(wakeup_timestamp),
};
int ret =
timerfd_settime(timer_fd, TFD_TIMER_ABSTIME, &wakeup_itimerspec, nullptr);
int error = errno;
if (ret < 0) {
ALOGE("HardwareComposer::SleepUntil: Failed to set timerfd: %s",
strerror(error));
return -error;
}
return PostThreadPollInterruptible(vsync_sleep_timer_fd_, POLLIN,
/*timeout_ms*/ -1);
}
void HardwareComposer::PostThread() {
// NOLINTNEXTLINE(runtime/int)
prctl(PR_SET_NAME, reinterpret_cast<unsigned long>("VrHwcPost"), 0, 0, 0);
// Set the scheduler to SCHED_FIFO with high priority. If this fails here
// there may have been a startup timing issue between this thread and
// performanced. Try again later when this thread becomes active.
bool thread_policy_setup =
SetThreadPolicy("graphics:high", "/system/performance");
// Create a timerfd based on CLOCK_MONOTINIC.
vsync_sleep_timer_fd_.Reset(timerfd_create(CLOCK_MONOTONIC, 0));
LOG_ALWAYS_FATAL_IF(
!vsync_sleep_timer_fd_,
"HardwareComposer: Failed to create vsync sleep timerfd: %s",
strerror(errno));
struct VsyncEyeOffsets { int64_t left_ns, right_ns; };
bool was_running = false;
auto get_vsync_eye_offsets = [this]() -> VsyncEyeOffsets {
VsyncEyeOffsets offsets;
offsets.left_ns =
GetPosePredictionTimeOffset(target_display_->vsync_period_ns);
// TODO(jbates) Query vblank time from device, when such an API is
// available. This value (6.3%) was measured on A00 in low persistence mode.
int64_t vblank_ns = target_display_->vsync_period_ns * 63 / 1000;
offsets.right_ns = (target_display_->vsync_period_ns - vblank_ns) / 2;
// Check property for overriding right eye offset value.
offsets.right_ns =
property_get_int64(kRightEyeOffsetProperty, offsets.right_ns);
return offsets;
};
VsyncEyeOffsets vsync_eye_offsets = get_vsync_eye_offsets();
if (is_standalone_device_) {
// First, wait until boot finishes.
std::unique_lock<std::mutex> lock(post_thread_mutex_);
if (PostThreadCondWait(lock, -1, [this] { return boot_finished_; })) {
return;
}
// Then, wait until we're either leaving the quiescent state, or the boot
// finished display off timeout expires.
if (PostThreadCondWait(lock, kBootFinishedDisplayOffTimeoutSec,
[this] { return !post_thread_quiescent_; })) {
return;
}
LOG_ALWAYS_FATAL_IF(post_thread_state_ & PostThreadState::Suspended,
"Vr flinger should own the display by now.");
post_thread_resumed_ = true;
post_thread_ready_.notify_all();
if (!composer_)
CreateComposer();
}
while (1) {
ATRACE_NAME("HardwareComposer::PostThread");
// Check for updated config once per vsync.
UpdateConfigBuffer();
while (post_thread_quiescent_) {
std::unique_lock<std::mutex> lock(post_thread_mutex_);
ALOGI("HardwareComposer::PostThread: Entering quiescent state.");
if (was_running) {
vsync_trace_parity_ = false;
ATRACE_INT(kVsyncTraceEventName, 0);
}
// Tear down resources.
OnPostThreadPaused();
was_running = false;
post_thread_resumed_ = false;
post_thread_ready_.notify_all();
if (PostThreadCondWait(lock, -1,
[this] { return !post_thread_quiescent_; })) {
// A true return value means we've been asked to quit.
return;
}
post_thread_resumed_ = true;
post_thread_ready_.notify_all();
ALOGI("HardwareComposer::PostThread: Exiting quiescent state.");
}
if (!composer_)
CreateComposer();
bool target_display_changed = UpdateTargetDisplay();
bool just_resumed_running = !was_running;
was_running = true;
if (target_display_changed)
vsync_eye_offsets = get_vsync_eye_offsets();
if (just_resumed_running) {
OnPostThreadResumed();
// Try to setup the scheduler policy if it failed during startup. Only
// attempt to do this on transitions from inactive to active to avoid
// spamming the system with RPCs and log messages.
if (!thread_policy_setup) {
thread_policy_setup =
SetThreadPolicy("graphics:high", "/system/performance");
}
}
if (target_display_changed || just_resumed_running) {
// Initialize the last vsync timestamp with the current time. The
// predictor below uses this time + the vsync interval in absolute time
// units for the initial delay. Once the driver starts reporting vsync the
// predictor will sync up with the real vsync.
last_vsync_timestamp_ = GetSystemClockNs();
vsync_prediction_interval_ = 1;
retire_fence_fds_.clear();
}
int64_t vsync_timestamp = 0;
{
TRACE_FORMAT("wait_vsync|vsync=%u;last_timestamp=%" PRId64
";prediction_interval=%d|",
vsync_count_ + 1, last_vsync_timestamp_,
vsync_prediction_interval_);
auto status = WaitForPredictedVSync();
ALOGE_IF(
!status,
"HardwareComposer::PostThread: Failed to wait for vsync event: %s",
status.GetErrorMessage().c_str());
// If there was an error either sleeping was interrupted due to pausing or
// there was an error getting the latest timestamp.
if (!status)
continue;
// Predicted vsync timestamp for this interval. This is stable because we
// use absolute time for the wakeup timer.
vsync_timestamp = status.get();
}
vsync_trace_parity_ = !vsync_trace_parity_;
ATRACE_INT(kVsyncTraceEventName, vsync_trace_parity_ ? 1 : 0);
// Advance the vsync counter only if the system is keeping up with hardware
// vsync to give clients an indication of the delays.
if (vsync_prediction_interval_ == 1)
++vsync_count_;
UpdateLayerConfig();
// Publish the vsync event.
if (vsync_ring_) {
DvrVsync vsync;
vsync.vsync_count = vsync_count_;
vsync.vsync_timestamp_ns = vsync_timestamp;
vsync.vsync_left_eye_offset_ns = vsync_eye_offsets.left_ns;
vsync.vsync_right_eye_offset_ns = vsync_eye_offsets.right_ns;
vsync.vsync_period_ns = target_display_->vsync_period_ns;
vsync_ring_->Publish(vsync);
}
{
// Sleep until shortly before vsync.
ATRACE_NAME("sleep");
const int64_t display_time_est_ns =
vsync_timestamp + target_display_->vsync_period_ns;
const int64_t now_ns = GetSystemClockNs();
const int64_t sleep_time_ns = display_time_est_ns - now_ns -
post_thread_config_.frame_post_offset_ns;
const int64_t wakeup_time_ns =
display_time_est_ns - post_thread_config_.frame_post_offset_ns;
ATRACE_INT64("sleep_time_ns", sleep_time_ns);
if (sleep_time_ns > 0) {
int error = SleepUntil(wakeup_time_ns);
ALOGE_IF(error < 0 && error != kPostThreadInterrupted,
"HardwareComposer::PostThread: Failed to sleep: %s",
strerror(-error));
// If the sleep was interrupted (error == kPostThreadInterrupted),
// we still go through and present this frame because we may have set
// layers earlier and we want to flush the Composer's internal command
// buffer by continuing through to validate and present.
}
}
{
auto status = composer_callback_->GetVsyncTime(target_display_->id);
// If we failed to read vsync there might be a problem with the driver.
// Since there's nothing we can do just behave as though we didn't get an
// updated vsync time and let the prediction continue.
const int64_t current_vsync_timestamp =
status ? status.get() : last_vsync_timestamp_;
const bool vsync_delayed =
last_vsync_timestamp_ == current_vsync_timestamp;
ATRACE_INT("vsync_delayed", vsync_delayed);
// If vsync was delayed advance the prediction interval and allow the
// fence logic in PostLayers() to skip the frame.
if (vsync_delayed) {
ALOGW(
"HardwareComposer::PostThread: VSYNC timestamp did not advance "
"since last frame: timestamp=%" PRId64 " prediction_interval=%d",
current_vsync_timestamp, vsync_prediction_interval_);
vsync_prediction_interval_++;
} else {
// We have an updated vsync timestamp, reset the prediction interval.
last_vsync_timestamp_ = current_vsync_timestamp;
vsync_prediction_interval_ = 1;
}
}
PostLayers(target_display_->id);
}
}
bool HardwareComposer::UpdateTargetDisplay() {
bool target_display_changed = false;
auto displays = composer_callback_->GetDisplays();
if (displays.external_display_was_hotplugged) {
bool was_using_external_display = !target_display_->is_primary;
if (was_using_external_display) {
// The external display was hotplugged, so make sure to ignore any bad
// display errors as we destroy the layers.
for (auto& layer: layers_)
layer.IgnoreBadDisplayErrorsOnDestroy(true);
}
if (displays.external_display) {
// External display was connected
external_display_ = GetDisplayParams(composer_.get(),
*displays.external_display, /*is_primary*/ false);
if (property_get_bool(kUseExternalDisplayProperty, false)) {
ALOGI("External display connected. Switching to external display.");
target_display_ = &(*external_display_);
target_display_changed = true;
} else {
ALOGI("External display connected, but sysprop %s is unset, so"
" using primary display.", kUseExternalDisplayProperty);
if (was_using_external_display) {
target_display_ = &primary_display_;
target_display_changed = true;
}
}
} else {
// External display was disconnected
external_display_ = std::nullopt;
if (was_using_external_display) {
ALOGI("External display disconnected. Switching to primary display.");
target_display_ = &primary_display_;
target_display_changed = true;
}
}
}
if (target_display_changed) {
// If we're switching to the external display, turn the primary display off.
if (!target_display_->is_primary) {
EnableDisplay(primary_display_, false);
}
// If we're switching to the primary display, and the external display is
// still connected, turn the external display off.
else if (target_display_->is_primary && external_display_) {
EnableDisplay(*external_display_, false);
}
// Turn the new target display on.
EnableDisplay(*target_display_, true);
// When we switch displays we need to recreate all the layers, so clear the
// current list, which will trigger layer recreation.
layers_.clear();
}
return target_display_changed;
}
// Checks for changes in the surface stack and updates the layer config to
// accomodate the new stack.
void HardwareComposer::UpdateLayerConfig() {
std::vector<std::shared_ptr<DirectDisplaySurface>> surfaces;
{
std::unique_lock<std::mutex> lock(post_thread_mutex_);
if (!surfaces_changed_ && (!layers_.empty() || surfaces_.empty()))
return;
surfaces = surfaces_;
surfaces_changed_ = false;
}
ATRACE_NAME("UpdateLayerConfig_HwLayers");
// Sort the new direct surface list by z-order to determine the relative order
// of the surfaces. This relative order is used for the HWC z-order value to
// insulate VrFlinger and HWC z-order semantics from each other.
std::sort(surfaces.begin(), surfaces.end(), [](const auto& a, const auto& b) {
return a->z_order() < b->z_order();
});
// Prepare a new layer stack, pulling in layers from the previous
// layer stack that are still active and updating their attributes.
std::vector<Layer> layers;
size_t layer_index = 0;
for (const auto& surface : surfaces) {
// The bottom layer is opaque, other layers blend.
HWC::BlendMode blending =
layer_index == 0 ? HWC::BlendMode::None : HWC::BlendMode::Coverage;
// Try to find a layer for this surface in the set of active layers.
auto search =
std::lower_bound(layers_.begin(), layers_.end(), surface->surface_id());
const bool found = search != layers_.end() &&
search->GetSurfaceId() == surface->surface_id();
if (found) {
// Update the attributes of the layer that may have changed.
search->SetBlending(blending);
search->SetZOrder(layer_index); // Relative z-order.
// Move the existing layer to the new layer set and remove the empty layer
// object from the current set.
layers.push_back(std::move(*search));
layers_.erase(search);
} else {
// Insert a layer for the new surface.
layers.emplace_back(composer_.get(), *target_display_, surface, blending,
HWC::Composition::Device, layer_index);
}
ALOGI_IF(
TRACE,
"HardwareComposer::UpdateLayerConfig: layer_index=%zu surface_id=%d",
layer_index, layers[layer_index].GetSurfaceId());
layer_index++;
}
// Sort the new layer stack by ascending surface id.
std::sort(layers.begin(), layers.end());
// Replace the previous layer set with the new layer set. The destructor of
// the previous set will clean up the remaining Layers that are not moved to
// the new layer set.
layers_ = std::move(layers);
ALOGD_IF(TRACE, "HardwareComposer::UpdateLayerConfig: %zd active layers",
layers_.size());
}
std::vector<sp<IVsyncCallback>>::const_iterator
HardwareComposer::VsyncService::FindCallback(
const sp<IVsyncCallback>& callback) const {
sp<IBinder> binder = IInterface::asBinder(callback);
return std::find_if(callbacks_.cbegin(), callbacks_.cend(),
[&](const sp<IVsyncCallback>& callback) {
return IInterface::asBinder(callback) == binder;
});
}
status_t HardwareComposer::VsyncService::registerCallback(
const sp<IVsyncCallback> callback) {
std::lock_guard<std::mutex> autolock(mutex_);
if (FindCallback(callback) == callbacks_.cend()) {
callbacks_.push_back(callback);
}
return OK;
}
status_t HardwareComposer::VsyncService::unregisterCallback(
const sp<IVsyncCallback> callback) {
std::lock_guard<std::mutex> autolock(mutex_);
auto iter = FindCallback(callback);
if (iter != callbacks_.cend()) {
callbacks_.erase(iter);
}
return OK;
}
void HardwareComposer::VsyncService::OnVsync(int64_t vsync_timestamp) {
ATRACE_NAME("VsyncService::OnVsync");
std::lock_guard<std::mutex> autolock(mutex_);
for (auto iter = callbacks_.begin(); iter != callbacks_.end();) {
if ((*iter)->onVsync(vsync_timestamp) == android::DEAD_OBJECT) {
iter = callbacks_.erase(iter);
} else {
++iter;
}
}
}
Return<void> HardwareComposer::ComposerCallback::onHotplug(
Hwc2::Display display, IComposerCallback::Connection conn) {
std::lock_guard<std::mutex> lock(mutex_);
ALOGI("onHotplug display=%" PRIu64 " conn=%d", display, conn);
bool is_primary = !got_first_hotplug_ || display == primary_display_.id;
// Our first onHotplug callback is always for the primary display.
if (!got_first_hotplug_) {
LOG_ALWAYS_FATAL_IF(conn != IComposerCallback::Connection::CONNECTED,
"Initial onHotplug callback should be primary display connected");
got_first_hotplug_ = true;
} else if (is_primary) {
ALOGE("Ignoring unexpected onHotplug() call for primary display");
return Void();
}
if (conn == IComposerCallback::Connection::CONNECTED) {
if (!is_primary)
external_display_ = DisplayInfo();
DisplayInfo& display_info = is_primary ?
primary_display_ : *external_display_;
display_info.id = display;
std::array<char, 1024> buffer;
snprintf(buffer.data(), buffer.size(),
"/sys/class/graphics/fb%" PRIu64 "/vsync_event", display);
if (LocalHandle handle{buffer.data(), O_RDONLY}) {
ALOGI(
"HardwareComposer::ComposerCallback::onHotplug: Driver supports "
"vsync_event node for display %" PRIu64,
display);
display_info.driver_vsync_event_fd = std::move(handle);
} else {
ALOGI(
"HardwareComposer::ComposerCallback::onHotplug: Driver does not "
"support vsync_event node for display %" PRIu64,
display);
}
} else if (conn == IComposerCallback::Connection::DISCONNECTED) {
external_display_ = std::nullopt;
}
if (!is_primary)
external_display_was_hotplugged_ = true;
return Void();
}
Return<void> HardwareComposer::ComposerCallback::onRefresh(
Hwc2::Display /*display*/) {
return hardware::Void();
}
Return<void> HardwareComposer::ComposerCallback::onVsync(Hwc2::Display display,
int64_t timestamp) {
TRACE_FORMAT("vsync_callback|display=%" PRIu64 ";timestamp=%" PRId64 "|",
display, timestamp);
std::lock_guard<std::mutex> lock(mutex_);
DisplayInfo* display_info = GetDisplayInfo(display);
if (display_info) {
display_info->callback_vsync_timestamp = timestamp;
}
if (primary_display_.id == display && vsync_service_ != nullptr) {
vsync_service_->OnVsync(timestamp);
}
return Void();
}
void HardwareComposer::ComposerCallback::SetVsyncService(
const sp<VsyncService>& vsync_service) {
std::lock_guard<std::mutex> lock(mutex_);
vsync_service_ = vsync_service;
}
HardwareComposer::ComposerCallback::Displays
HardwareComposer::ComposerCallback::GetDisplays() {
std::lock_guard<std::mutex> lock(mutex_);
Displays displays;
displays.primary_display = primary_display_.id;
if (external_display_)
displays.external_display = external_display_->id;
if (external_display_was_hotplugged_) {
external_display_was_hotplugged_ = false;
displays.external_display_was_hotplugged = true;
}
return displays;
}
Status<int64_t> HardwareComposer::ComposerCallback::GetVsyncTime(
hwc2_display_t display) {
std::lock_guard<std::mutex> autolock(mutex_);
DisplayInfo* display_info = GetDisplayInfo(display);
if (!display_info) {
ALOGW("Attempt to get vsync time for unknown display %" PRIu64, display);
return ErrorStatus(EINVAL);
}
// See if the driver supports direct vsync events.
LocalHandle& event_fd = display_info->driver_vsync_event_fd;
if (!event_fd) {
// Fall back to returning the last timestamp returned by the vsync
// callback.
return display_info->callback_vsync_timestamp;
}
// When the driver supports the vsync_event sysfs node we can use it to
// determine the latest vsync timestamp, even if the HWC callback has been
// delayed.
// The driver returns data in the form "VSYNC=<timestamp ns>".
std::array<char, 32> data;
data.fill('\0');
// Seek back to the beginning of the event file.
int ret = lseek(event_fd.Get(), 0, SEEK_SET);
if (ret < 0) {
const int error = errno;
ALOGE(
"HardwareComposer::ComposerCallback::GetVsyncTime: Failed to seek "
"vsync event fd: %s",
strerror(error));
return ErrorStatus(error);
}
// Read the vsync event timestamp.
ret = read(event_fd.Get(), data.data(), data.size());
if (ret < 0) {
const int error = errno;
ALOGE_IF(error != EAGAIN,
"HardwareComposer::ComposerCallback::GetVsyncTime: Error "
"while reading timestamp: %s",
strerror(error));
return ErrorStatus(error);
}
int64_t timestamp;
ret = sscanf(data.data(), "VSYNC=%" PRIu64,
reinterpret_cast<uint64_t*>(×tamp));
if (ret < 0) {
const int error = errno;
ALOGE(
"HardwareComposer::ComposerCallback::GetVsyncTime: Error while "
"parsing timestamp: %s",
strerror(error));
return ErrorStatus(error);
}
return {timestamp};
}
HardwareComposer::ComposerCallback::DisplayInfo*
HardwareComposer::ComposerCallback::GetDisplayInfo(hwc2_display_t display) {
if (display == primary_display_.id) {
return &primary_display_;
} else if (external_display_ && display == external_display_->id) {
return &(*external_display_);
}
return nullptr;
}
void Layer::Reset() {
if (hardware_composer_layer_) {
HWC::Error error =
composer_->destroyLayer(display_params_.id, hardware_composer_layer_);
if (error != HWC::Error::None &&
(!ignore_bad_display_errors_on_destroy_ ||
error != HWC::Error::BadDisplay)) {
ALOGE("destroyLayer() failed for display %" PRIu64 ", layer %" PRIu64
". error: %s", display_params_.id, hardware_composer_layer_,
error.to_string().c_str());
}
hardware_composer_layer_ = 0;
}
z_order_ = 0;
blending_ = HWC::BlendMode::None;
composition_type_ = HWC::Composition::Invalid;
target_composition_type_ = composition_type_;
source_ = EmptyVariant{};
acquire_fence_.Close();
surface_rect_functions_applied_ = false;
pending_visibility_settings_ = true;
cached_buffer_map_.clear();
ignore_bad_display_errors_on_destroy_ = false;
}
Layer::Layer(Hwc2::Composer* composer, const DisplayParams& display_params,
const std::shared_ptr<DirectDisplaySurface>& surface,
HWC::BlendMode blending, HWC::Composition composition_type,
size_t z_order)
: composer_(composer),
display_params_(display_params),
z_order_{z_order},
blending_{blending},
target_composition_type_{composition_type},
source_{SourceSurface{surface}} {
CommonLayerSetup();
}
Layer::Layer(Hwc2::Composer* composer, const DisplayParams& display_params,
const std::shared_ptr<IonBuffer>& buffer, HWC::BlendMode blending,
HWC::Composition composition_type, size_t z_order)
: composer_(composer),
display_params_(display_params),
z_order_{z_order},
blending_{blending},
target_composition_type_{composition_type},
source_{SourceBuffer{buffer}} {
CommonLayerSetup();
}
Layer::~Layer() { Reset(); }
Layer::Layer(Layer&& other) noexcept { *this = std::move(other); }
Layer& Layer::operator=(Layer&& other) noexcept {
if (this != &other) {
Reset();
using std::swap;
swap(composer_, other.composer_);
swap(display_params_, other.display_params_);
swap(hardware_composer_layer_, other.hardware_composer_layer_);
swap(z_order_, other.z_order_);
swap(blending_, other.blending_);
swap(composition_type_, other.composition_type_);
swap(target_composition_type_, other.target_composition_type_);
swap(source_, other.source_);
swap(acquire_fence_, other.acquire_fence_);
swap(surface_rect_functions_applied_,
other.surface_rect_functions_applied_);
swap(pending_visibility_settings_, other.pending_visibility_settings_);
swap(cached_buffer_map_, other.cached_buffer_map_);
swap(ignore_bad_display_errors_on_destroy_,
other.ignore_bad_display_errors_on_destroy_);
}
return *this;
}
void Layer::UpdateBuffer(const std::shared_ptr<IonBuffer>& buffer) {
if (source_.is<SourceBuffer>())
std::get<SourceBuffer>(source_) = {buffer};
}
void Layer::SetBlending(HWC::BlendMode blending) {
if (blending_ != blending) {
blending_ = blending;
pending_visibility_settings_ = true;
}
}
void Layer::SetZOrder(size_t z_order) {
if (z_order_ != z_order) {
z_order_ = z_order;
pending_visibility_settings_ = true;
}
}
IonBuffer* Layer::GetBuffer() {
struct Visitor {
IonBuffer* operator()(SourceSurface& source) { return source.GetBuffer(); }
IonBuffer* operator()(SourceBuffer& source) { return source.GetBuffer(); }
IonBuffer* operator()(EmptyVariant) { return nullptr; }
};
return source_.Visit(Visitor{});
}
void Layer::UpdateVisibilitySettings() {
if (pending_visibility_settings_) {
pending_visibility_settings_ = false;
HWC::Error error;
error = composer_->setLayerBlendMode(
display_params_.id, hardware_composer_layer_,
blending_.cast<Hwc2::IComposerClient::BlendMode>());
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting layer blend mode: %s",
error.to_string().c_str());
error = composer_->setLayerZOrder(display_params_.id,
hardware_composer_layer_, z_order_);
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting z_ order: %s",
error.to_string().c_str());
}
}
void Layer::UpdateLayerSettings() {
HWC::Error error;
UpdateVisibilitySettings();
// TODO(eieio): Use surface attributes or some other mechanism to control
// the layer display frame.
error = composer_->setLayerDisplayFrame(
display_params_.id, hardware_composer_layer_,
{0, 0, display_params_.width, display_params_.height});
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting layer display frame: %s",
error.to_string().c_str());
error = composer_->setLayerVisibleRegion(
display_params_.id, hardware_composer_layer_,
{{0, 0, display_params_.width, display_params_.height}});
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting layer visible region: %s",
error.to_string().c_str());
error = composer_->setLayerPlaneAlpha(display_params_.id,
hardware_composer_layer_, 1.0f);
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting layer plane alpha: %s",
error.to_string().c_str());
}
void Layer::CommonLayerSetup() {
HWC::Error error = composer_->createLayer(display_params_.id,
&hardware_composer_layer_);
ALOGE_IF(error != HWC::Error::None,
"Layer::CommonLayerSetup: Failed to create layer on primary "
"display: %s",
error.to_string().c_str());
UpdateLayerSettings();
}
bool Layer::CheckAndUpdateCachedBuffer(std::size_t slot, int buffer_id) {
auto search = cached_buffer_map_.find(slot);
if (search != cached_buffer_map_.end() && search->second == buffer_id)
return true;
// Assign or update the buffer slot.
if (buffer_id >= 0)
cached_buffer_map_[slot] = buffer_id;
return false;
}
void Layer::Prepare() {
int right, bottom, id;
sp<GraphicBuffer> handle;
std::size_t slot;
// Acquire the next buffer according to the type of source.
IfAnyOf<SourceSurface, SourceBuffer>::Call(&source_, [&](auto& source) {
std::tie(right, bottom, id, handle, acquire_fence_, slot) =
source.Acquire();
});
TRACE_FORMAT("Layer::Prepare|buffer_id=%d;slot=%zu|", id, slot);
// Update any visibility (blending, z-order) changes that occurred since
// last prepare.
UpdateVisibilitySettings();
// When a layer is first setup there may be some time before the first
// buffer arrives. Setup the HWC layer as a solid color to stall for time
// until the first buffer arrives. Once the first buffer arrives there will
// always be a buffer for the frame even if it is old.
if (!handle.get()) {
if (composition_type_ == HWC::Composition::Invalid) {
composition_type_ = HWC::Composition::SolidColor;
composer_->setLayerCompositionType(
display_params_.id, hardware_composer_layer_,
composition_type_.cast<Hwc2::IComposerClient::Composition>());
Hwc2::IComposerClient::Color layer_color = {0, 0, 0, 0};
composer_->setLayerColor(display_params_.id, hardware_composer_layer_,
layer_color);
} else {
// The composition type is already set. Nothing else to do until a
// buffer arrives.
}
} else {
if (composition_type_ != target_composition_type_) {
composition_type_ = target_composition_type_;
composer_->setLayerCompositionType(
display_params_.id, hardware_composer_layer_,
composition_type_.cast<Hwc2::IComposerClient::Composition>());
}
// See if the HWC cache already has this buffer.
const bool cached = CheckAndUpdateCachedBuffer(slot, id);
if (cached)
handle = nullptr;
HWC::Error error{HWC::Error::None};
error =
composer_->setLayerBuffer(display_params_.id, hardware_composer_layer_,
slot, handle, acquire_fence_.Get());
ALOGE_IF(error != HWC::Error::None,
"Layer::Prepare: Error setting layer buffer: %s",
error.to_string().c_str());
if (!surface_rect_functions_applied_) {
const float float_right = right;
const float float_bottom = bottom;
error = composer_->setLayerSourceCrop(display_params_.id,
hardware_composer_layer_,
{0, 0, float_right, float_bottom});
ALOGE_IF(error != HWC::Error::None,
"Layer::Prepare: Error setting layer source crop: %s",
error.to_string().c_str());
surface_rect_functions_applied_ = true;
}
}
}
void Layer::Finish(int release_fence_fd) {
IfAnyOf<SourceSurface, SourceBuffer>::Call(
&source_, [release_fence_fd](auto& source) {
source.Finish(LocalHandle(release_fence_fd));
});
}
void Layer::Drop() { acquire_fence_.Close(); }
} // namespace dvr
} // namespace android