| #include "hardware_composer.h" |
| |
| #include <cutils/properties.h> |
| #include <cutils/sched_policy.h> |
| #include <fcntl.h> |
| #include <log/log.h> |
| #include <poll.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 <time.h> |
| #include <unistd.h> |
| #include <utils/Trace.h> |
| |
| #include <algorithm> |
| #include <chrono> |
| #include <functional> |
| #include <map> |
| |
| #include <dvr/dvr_display_types.h> |
| #include <dvr/performance_client_api.h> |
| #include <private/dvr/clock_ns.h> |
| #include <private/dvr/ion_buffer.h> |
| #include <private/dvr/pose_client_internal.h> |
| |
| using android::pdx::LocalHandle; |
| using android::pdx::rpc::EmptyVariant; |
| using android::pdx::rpc::IfAnyOf; |
| |
| using namespace std::chrono_literals; |
| |
| namespace android { |
| namespace dvr { |
| |
| namespace { |
| |
| // If the number of pending fences goes over this count at the point when we |
| // are about to submit a new frame to HWC, we will drop the frame. This should |
| // be a signal that the display driver has begun queuing frames. Note that with |
| // smart displays (with RAM), the fence is signaled earlier than the next vsync, |
| // at the point when the DMA to the display completes. Currently we use a smart |
| // display and the EDS timing coincides with zero pending fences, so this is 0. |
| constexpr int kAllowedPendingFenceCount = 0; |
| |
| // Offset before vsync to submit frames to hardware composer. |
| constexpr int64_t kFramePostOffsetNs = 4000000; // 4ms |
| |
| const char kBacklightBrightnessSysFile[] = |
| "/sys/class/leds/lcd-backlight/brightness"; |
| |
| const char kPrimaryDisplayVSyncEventFile[] = |
| "/sys/class/graphics/fb0/vsync_event"; |
| |
| const char kPrimaryDisplayWaitPPEventFile[] = "/sys/class/graphics/fb0/wait_pp"; |
| |
| const char kDvrPerformanceProperty[] = "sys.dvr.performance"; |
| |
| const char kRightEyeOffsetProperty[] = "dvr.right_eye_offset_ns"; |
| |
| // 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; |
| } |
| |
| } // anonymous namespace |
| |
| // Layer static data. |
| Hwc2::Composer* Layer::hwc2_hidl_; |
| const HWCDisplayMetrics* Layer::display_metrics_; |
| |
| // HardwareComposer static data; |
| constexpr size_t HardwareComposer::kMaxHardwareLayers; |
| |
| HardwareComposer::HardwareComposer() |
| : HardwareComposer(nullptr, RequestDisplayCallback()) {} |
| |
| HardwareComposer::HardwareComposer( |
| Hwc2::Composer* hwc2_hidl, RequestDisplayCallback request_display_callback) |
| : initialized_(false), |
| hwc2_hidl_(hwc2_hidl), |
| request_display_callback_(request_display_callback), |
| callbacks_(new ComposerCallback) {} |
| |
| HardwareComposer::~HardwareComposer(void) { |
| UpdatePostThreadState(PostThreadState::Quit, true); |
| if (post_thread_.joinable()) |
| post_thread_.join(); |
| } |
| |
| bool HardwareComposer::Initialize() { |
| if (initialized_) { |
| ALOGE("HardwareComposer::Initialize: already initialized."); |
| return false; |
| } |
| |
| HWC::Error error = HWC::Error::None; |
| |
| Hwc2::Config config; |
| error = hwc2_hidl_->getActiveConfig(HWC_DISPLAY_PRIMARY, &config); |
| |
| if (error != HWC::Error::None) { |
| ALOGE("HardwareComposer: Failed to get current display config : %d", |
| config); |
| return false; |
| } |
| |
| error = |
| GetDisplayMetrics(HWC_DISPLAY_PRIMARY, config, &native_display_metrics_); |
| |
| if (error != HWC::Error::None) { |
| ALOGE( |
| "HardwareComposer: Failed to get display attributes for current " |
| "configuration : %d", |
| error.value); |
| return false; |
| } |
| |
| ALOGI( |
| "HardwareComposer: primary display attributes: width=%d height=%d " |
| "vsync_period_ns=%d DPI=%dx%d", |
| native_display_metrics_.width, native_display_metrics_.height, |
| native_display_metrics_.vsync_period_ns, native_display_metrics_.dpi.x, |
| native_display_metrics_.dpi.y); |
| |
| // Set the display metrics but never use rotation to avoid the long latency of |
| // rotation processing in hwc. |
| display_transform_ = HWC_TRANSFORM_NONE; |
| display_metrics_ = native_display_metrics_; |
| |
| // Pass hwc instance and metrics to setup globals for Layer. |
| Layer::InitializeGlobals(hwc2_hidl_, &native_display_metrics_); |
| |
| 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); |
| } |
| |
| // 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(); |
| } |
| |
| // Wait until the post thread is in the requested state. |
| post_thread_ready_.wait(lock, [this, effective_suspend] { |
| return effective_suspend != post_thread_resumed_; |
| }); |
| } |
| |
| void HardwareComposer::OnPostThreadResumed() { |
| hwc2_hidl_->resetCommands(); |
| |
| // Connect to pose service. |
| pose_client_ = dvrPoseCreate(); |
| ALOGE_IF(!pose_client_, "HardwareComposer: Failed to create pose client"); |
| |
| // HIDL HWC seems to have an internal race condition. If we submit a frame too |
| // soon after turning on VSync we don't get any VSync signals. Give poor HWC |
| // implementations a chance to enable VSync before we continue. |
| EnableVsync(false); |
| std::this_thread::sleep_for(100ms); |
| EnableVsync(true); |
| std::this_thread::sleep_for(100ms); |
| |
| // TODO(skiazyk): We need to do something about accessing this directly, |
| // supposedly there is a backlight service on the way. |
| // TODO(steventhomas): When we change the backlight setting, will surface |
| // flinger (or something else) set it back to its original value once we give |
| // control of the display back to surface flinger? |
| SetBacklightBrightness(255); |
| |
| // Trigger target-specific performance mode change. |
| property_set(kDvrPerformanceProperty, "performance"); |
| } |
| |
| void HardwareComposer::OnPostThreadPaused() { |
| retire_fence_fds_.clear(); |
| display_surfaces_.clear(); |
| |
| for (size_t i = 0; i < kMaxHardwareLayers; ++i) { |
| layers_[i].Reset(); |
| } |
| active_layer_count_ = 0; |
| |
| if (pose_client_) { |
| dvrPoseDestroy(pose_client_); |
| pose_client_ = nullptr; |
| } |
| |
| EnableVsync(false); |
| |
| hwc2_hidl_->resetCommands(); |
| |
| // Trigger target-specific performance mode change. |
| property_set(kDvrPerformanceProperty, "idle"); |
| } |
| |
| HWC::Error HardwareComposer::Validate(hwc2_display_t display) { |
| uint32_t num_types; |
| uint32_t num_requests; |
| HWC::Error error = |
| hwc2_hidl_->validateDisplay(display, &num_types, &num_requests); |
| |
| if (error == HWC2_ERROR_HAS_CHANGES) { |
| // TODO(skiazyk): We might need to inspect the requested changes first, but |
| // so far it seems like we shouldn't ever hit a bad state. |
| // error = hwc2_funcs_.accept_display_changes_fn_(hardware_composer_device_, |
| // display); |
| error = hwc2_hidl_->acceptDisplayChanges(display); |
| } |
| |
| return error; |
| } |
| |
| int32_t HardwareComposer::EnableVsync(bool enabled) { |
| return (int32_t)hwc2_hidl_->setVsyncEnabled( |
| HWC_DISPLAY_PRIMARY, |
| (Hwc2::IComposerClient::Vsync)(enabled ? HWC2_VSYNC_ENABLE |
| : HWC2_VSYNC_DISABLE)); |
| } |
| |
| HWC::Error HardwareComposer::Present(hwc2_display_t display) { |
| int32_t present_fence; |
| HWC::Error error = hwc2_hidl_->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) { |
| ATRACE_INT("HardwareComposer: VsyncFence", present_fence); |
| retire_fence_fds_.emplace_back(present_fence); |
| } else { |
| ATRACE_INT("HardwareComposer: PresentResult", error); |
| } |
| |
| return error; |
| } |
| |
| HWC::Error HardwareComposer::GetDisplayAttribute(hwc2_display_t display, |
| hwc2_config_t config, |
| hwc2_attribute_t attribute, |
| int32_t* out_value) const { |
| return hwc2_hidl_->getDisplayAttribute( |
| display, config, (Hwc2::IComposerClient::Attribute)attribute, out_value); |
| } |
| |
| HWC::Error HardwareComposer::GetDisplayMetrics( |
| hwc2_display_t display, hwc2_config_t config, |
| HWCDisplayMetrics* out_metrics) const { |
| HWC::Error error; |
| |
| error = GetDisplayAttribute(display, config, HWC2_ATTRIBUTE_WIDTH, |
| &out_metrics->width); |
| if (error != HWC::Error::None) { |
| ALOGE( |
| "HardwareComposer::GetDisplayMetrics: Failed to get display width: %s", |
| error.to_string().c_str()); |
| return error; |
| } |
| |
| error = GetDisplayAttribute(display, config, HWC2_ATTRIBUTE_HEIGHT, |
| &out_metrics->height); |
| if (error != HWC::Error::None) { |
| ALOGE( |
| "HardwareComposer::GetDisplayMetrics: Failed to get display height: %s", |
| error.to_string().c_str()); |
| return error; |
| } |
| |
| error = GetDisplayAttribute(display, config, HWC2_ATTRIBUTE_VSYNC_PERIOD, |
| &out_metrics->vsync_period_ns); |
| if (error != HWC::Error::None) { |
| ALOGE( |
| "HardwareComposer::GetDisplayMetrics: Failed to get display height: %s", |
| error.to_string().c_str()); |
| return error; |
| } |
| |
| error = GetDisplayAttribute(display, config, HWC2_ATTRIBUTE_DPI_X, |
| &out_metrics->dpi.x); |
| if (error != HWC::Error::None) { |
| ALOGE( |
| "HardwareComposer::GetDisplayMetrics: Failed to get display DPI X: %s", |
| error.to_string().c_str()); |
| return error; |
| } |
| |
| error = GetDisplayAttribute(display, config, HWC2_ATTRIBUTE_DPI_Y, |
| &out_metrics->dpi.y); |
| if (error != HWC::Error::None) { |
| ALOGE( |
| "HardwareComposer::GetDisplayMetrics: Failed to get display DPI Y: %s", |
| error.to_string().c_str()); |
| return error; |
| } |
| |
| return HWC::Error::None; |
| } |
| |
| std::string HardwareComposer::Dump() { return hwc2_hidl_->dumpDebugInfo(); } |
| |
| void HardwareComposer::PostLayers() { |
| ATRACE_NAME("HardwareComposer::PostLayers"); |
| |
| // Setup the hardware composer layers with current buffers. |
| for (size_t i = 0; i < active_layer_count_; i++) { |
| layers_[i].Prepare(); |
| } |
| |
| HWC::Error error = Validate(HWC_DISPLAY_PRIMARY); |
| if (error != HWC::Error::None) { |
| ALOGE("HardwareComposer::PostLayers: Validate failed: %s", |
| error.to_string().c_str()); |
| return; |
| } |
| |
| // 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_frame_pending = IsFramePendingInDriver(); |
| const bool is_fence_pending = |
| retire_fence_fds_.size() > kAllowedPendingFenceCount; |
| |
| if (is_fence_pending || is_frame_pending) { |
| ATRACE_INT("frame_skip_count", ++frame_skip_count_); |
| |
| ALOGW_IF(is_frame_pending, "Warning: frame already queued, dropping frame"); |
| ALOGW_IF(is_fence_pending, |
| "Warning: dropping a frame to catch up with HWC (pending = %zd)", |
| retire_fence_fds_.size()); |
| |
| for (size_t i = 0; i < active_layer_count_; i++) { |
| layers_[i].Drop(); |
| } |
| return; |
| } else { |
| // Make the transition more obvious in systrace when the frame skip happens |
| // above. |
| ATRACE_INT("frame_skip_count", 0); |
| } |
| |
| #if TRACE |
| for (size_t i = 0; i < active_layer_count_; i++) |
| ALOGI("HardwareComposer::PostLayers: layer=%zu composition=%s", i, |
| layers_[i].GetCompositionType().to_string().c_str()); |
| #endif |
| |
| error = Present(HWC_DISPLAY_PRIMARY); |
| 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 = hwc2_hidl_->getReleaseFences(HWC_DISPLAY_PRIMARY, &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. Unused layers are a no-op. |
| uint32_t num_elements = out_layers.size(); |
| for (size_t i = 0; i < num_elements; ++i) { |
| for (size_t j = 0; j < active_layer_count_; ++j) { |
| if (layers_[j].GetLayerHandle() == out_layers[i]) { |
| layers_[j].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_); |
| pending_surfaces_ = std::move(surfaces); |
| } |
| |
| // Set idle state based on whether there are any surfaces to handle. |
| UpdatePostThreadState(PostThreadState::Idle, display_idle); |
| |
| // XXX: TEMPORARY |
| // Request control of the display based on whether there are any surfaces to |
| // handle. This callback sets the post thread active state once the transition |
| // is complete in SurfaceFlinger. |
| // TODO(eieio): Unify the control signal used to move SurfaceFlinger into VR |
| // mode. Currently this is hooked up to persistent VR mode, but perhaps this |
| // makes more sense to control it from VrCore, which could in turn base its |
| // decision on persistent VR mode. |
| if (request_display_callback_) |
| request_display_callback_(!display_idle); |
| } |
| |
| int HardwareComposer::PostThreadPollInterruptible( |
| const pdx::LocalHandle& event_fd, int requested_events) { |
| 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, -1); |
| 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 (pfd[0].revents != 0) { |
| return 0; |
| } else if (pfd[1].revents != 0) { |
| ALOGI("VrHwcPost thread interrupted"); |
| return kPostThreadInterrupted; |
| } else { |
| return 0; |
| } |
| } |
| |
| // Reads the value of the display driver wait_pingpong state. Returns 0 or 1 |
| // (the value of the state) on success or a negative error otherwise. |
| // TODO(eieio): This is pretty driver specific, this should be moved to a |
| // separate class eventually. |
| int HardwareComposer::ReadWaitPPState() { |
| // Gracefully handle when the kernel does not support this feature. |
| if (!primary_display_wait_pp_fd_) |
| return 0; |
| |
| const int wait_pp_fd = primary_display_wait_pp_fd_.Get(); |
| int ret, error; |
| |
| ret = lseek(wait_pp_fd, 0, SEEK_SET); |
| if (ret < 0) { |
| error = errno; |
| ALOGE("HardwareComposer::ReadWaitPPState: Failed to seek wait_pp fd: %s", |
| strerror(error)); |
| return -error; |
| } |
| |
| char data = -1; |
| ret = read(wait_pp_fd, &data, sizeof(data)); |
| if (ret < 0) { |
| error = errno; |
| ALOGE("HardwareComposer::ReadWaitPPState: Failed to read wait_pp state: %s", |
| strerror(error)); |
| return -error; |
| } |
| |
| switch (data) { |
| case '0': |
| return 0; |
| case '1': |
| return 1; |
| default: |
| ALOGE( |
| "HardwareComposer::ReadWaitPPState: Unexpected value for wait_pp: %d", |
| data); |
| return -EINVAL; |
| } |
| } |
| |
| // Reads the timestamp of the last vsync from the display driver. |
| // TODO(eieio): This is pretty driver specific, this should be moved to a |
| // separate class eventually. |
| int HardwareComposer::ReadVSyncTimestamp(int64_t* timestamp) { |
| const int event_fd = primary_display_vsync_event_fd_.Get(); |
| int ret, error; |
| |
| // 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. |
| ret = lseek(event_fd, 0, SEEK_SET); |
| if (ret < 0) { |
| error = errno; |
| ALOGE( |
| "HardwareComposer::ReadVSyncTimestamp: Failed to seek vsync event fd: " |
| "%s", |
| strerror(error)); |
| return -error; |
| } |
| |
| // Read the vsync event timestamp. |
| ret = read(event_fd, data.data(), data.size()); |
| if (ret < 0) { |
| error = errno; |
| ALOGE_IF( |
| error != EAGAIN, |
| "HardwareComposer::ReadVSyncTimestamp: Error while reading timestamp: " |
| "%s", |
| strerror(error)); |
| return -error; |
| } |
| |
| ret = sscanf(data.data(), "VSYNC=%" PRIu64, |
| reinterpret_cast<uint64_t*>(timestamp)); |
| if (ret < 0) { |
| error = errno; |
| ALOGE( |
| "HardwareComposer::ReadVSyncTimestamp: Error while parsing timestamp: " |
| "%s", |
| strerror(error)); |
| return -error; |
| } |
| |
| return 0; |
| } |
| |
| // Blocks until the next vsync event is signaled by the display driver. |
| // TODO(eieio): This is pretty driver specific, this should be moved to a |
| // separate class eventually. |
| int HardwareComposer::BlockUntilVSync() { |
| // Vsync is signaled by POLLPRI on the fb vsync node. |
| return PostThreadPollInterruptible(primary_display_vsync_event_fd_, POLLPRI); |
| } |
| |
| // Waits for the next vsync and returns the timestamp of the vsync event. If |
| // vsync already passed since the last call, returns the latest vsync timestamp |
| // instead of blocking. This method updates the last_vsync_timeout_ in the |
| // process. |
| // |
| // TODO(eieio): This is pretty driver specific, this should be moved to a |
| // separate class eventually. |
| int HardwareComposer::WaitForVSync(int64_t* timestamp) { |
| int error; |
| |
| // Get the current timestamp and decide what to do. |
| while (true) { |
| int64_t current_vsync_timestamp; |
| error = ReadVSyncTimestamp(¤t_vsync_timestamp); |
| if (error < 0 && error != -EAGAIN) |
| return error; |
| |
| if (error == -EAGAIN) { |
| // Vsync was turned off, wait for the next vsync event. |
| error = BlockUntilVSync(); |
| if (error < 0 || error == kPostThreadInterrupted) |
| return error; |
| |
| // Try again to get the timestamp for this new vsync interval. |
| continue; |
| } |
| |
| // Check that we advanced to a later vsync interval. |
| if (TimestampGT(current_vsync_timestamp, last_vsync_timestamp_)) { |
| *timestamp = last_vsync_timestamp_ = current_vsync_timestamp; |
| return 0; |
| } |
| |
| // See how close we are to the next expected vsync. If we're within 1ms, |
| // sleep for 1ms and try again. |
| const int64_t ns_per_frame = display_metrics_.vsync_period_ns; |
| const int64_t threshold_ns = 1000000; // 1ms |
| |
| const int64_t next_vsync_est = last_vsync_timestamp_ + ns_per_frame; |
| const int64_t distance_to_vsync_est = next_vsync_est - GetSystemClockNs(); |
| |
| if (distance_to_vsync_est > threshold_ns) { |
| // Wait for vsync event notification. |
| error = BlockUntilVSync(); |
| if (error < 0 || error == kPostThreadInterrupted) |
| return error; |
| } else { |
| // Sleep for a short time (1 millisecond) before retrying. |
| error = SleepUntil(GetSystemClockNs() + threshold_ns); |
| if (error < 0 || error == kPostThreadInterrupted) |
| return error; |
| } |
| } |
| } |
| |
| 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); |
| } |
| |
| 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"); |
| |
| #if ENABLE_BACKLIGHT_BRIGHTNESS |
| // TODO(hendrikw): This isn't required at the moment. It's possible that there |
| // is another method to access this when needed. |
| // Open the backlight brightness control sysfs node. |
| backlight_brightness_fd_ = LocalHandle(kBacklightBrightnessSysFile, O_RDWR); |
| ALOGW_IF(!backlight_brightness_fd_, |
| "HardwareComposer: Failed to open backlight brightness control: %s", |
| strerror(errno)); |
| #endif // ENABLE_BACKLIGHT_BRIGHTNESS |
| |
| // Open the vsync event node for the primary display. |
| // TODO(eieio): Move this into a platform-specific class. |
| primary_display_vsync_event_fd_ = |
| LocalHandle(kPrimaryDisplayVSyncEventFile, O_RDONLY); |
| ALOGE_IF(!primary_display_vsync_event_fd_, |
| "HardwareComposer: Failed to open vsync event node for primary " |
| "display: %s", |
| strerror(errno)); |
| |
| // Open the wait pingpong status node for the primary display. |
| // TODO(eieio): Move this into a platform-specific class. |
| primary_display_wait_pp_fd_ = |
| LocalHandle(kPrimaryDisplayWaitPPEventFile, O_RDONLY); |
| ALOGW_IF( |
| !primary_display_wait_pp_fd_, |
| "HardwareComposer: Failed to open wait_pp node for primary display: %s", |
| strerror(errno)); |
| |
| // 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)); |
| |
| const int64_t ns_per_frame = display_metrics_.vsync_period_ns; |
| const int64_t photon_offset_ns = GetPosePredictionTimeOffset(ns_per_frame); |
| |
| // 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 = ns_per_frame * 63 / 1000; |
| int64_t right_eye_photon_offset_ns = (ns_per_frame - vblank_ns) / 2; |
| |
| // Check property for overriding right eye offset value. |
| right_eye_photon_offset_ns = |
| property_get_int64(kRightEyeOffsetProperty, right_eye_photon_offset_ns); |
| |
| bool was_running = false; |
| |
| while (1) { |
| ATRACE_NAME("HardwareComposer::PostThread"); |
| |
| while (post_thread_quiescent_) { |
| std::unique_lock<std::mutex> lock(post_thread_mutex_); |
| ALOGI("HardwareComposer::PostThread: Entering quiescent state."); |
| |
| // Tear down resources. |
| OnPostThreadPaused(); |
| |
| was_running = false; |
| post_thread_resumed_ = false; |
| post_thread_ready_.notify_all(); |
| |
| if (post_thread_state_ & PostThreadState::Quit) { |
| ALOGI("HardwareComposer::PostThread: Quitting."); |
| return; |
| } |
| |
| post_thread_wait_.wait(lock, [this] { return !post_thread_quiescent_; }); |
| |
| post_thread_resumed_ = true; |
| post_thread_ready_.notify_all(); |
| |
| ALOGI("HardwareComposer::PostThread: Exiting quiescent state."); |
| } |
| |
| if (!was_running) { |
| // Setup resources. |
| OnPostThreadResumed(); |
| was_running = true; |
| |
| // 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"); |
| } |
| } |
| |
| int64_t vsync_timestamp = 0; |
| { |
| std::array<char, 128> buf; |
| snprintf(buf.data(), buf.size(), "wait_vsync|vsync=%d|", |
| vsync_count_ + 1); |
| ATRACE_NAME(buf.data()); |
| |
| const int error = WaitForVSync(&vsync_timestamp); |
| ALOGE_IF( |
| error < 0, |
| "HardwareComposer::PostThread: Failed to wait for vsync event: %s", |
| strerror(-error)); |
| // Don't bother processing this frame if a pause was requested |
| if (error == kPostThreadInterrupted) |
| continue; |
| } |
| |
| ++vsync_count_; |
| |
| if (pose_client_) { |
| // Signal the pose service with vsync info. |
| // Display timestamp is in the middle of scanout. |
| privateDvrPoseNotifyVsync(pose_client_, vsync_count_, |
| vsync_timestamp + photon_offset_ns, |
| ns_per_frame, right_eye_photon_offset_ns); |
| } |
| |
| const bool layer_config_changed = UpdateLayerConfig(); |
| |
| // Signal all of the vsync clients. Because absolute time is used for the |
| // wakeup time below, this can take a little time if necessary. |
| if (vsync_callback_) |
| vsync_callback_(HWC_DISPLAY_PRIMARY, vsync_timestamp, |
| /*frame_time_estimate*/ 0, vsync_count_); |
| |
| { |
| // Sleep until shortly before vsync. |
| ATRACE_NAME("sleep"); |
| |
| const int64_t display_time_est_ns = vsync_timestamp + ns_per_frame; |
| const int64_t now_ns = GetSystemClockNs(); |
| const int64_t sleep_time_ns = |
| display_time_est_ns - now_ns - kFramePostOffsetNs; |
| const int64_t wakeup_time_ns = display_time_est_ns - kFramePostOffsetNs; |
| |
| ATRACE_INT64("sleep_time_ns", sleep_time_ns); |
| if (sleep_time_ns > 0) { |
| int error = SleepUntil(wakeup_time_ns); |
| ALOGE_IF(error < 0, "HardwareComposer::PostThread: Failed to sleep: %s", |
| strerror(-error)); |
| if (error == kPostThreadInterrupted) { |
| if (layer_config_changed) { |
| // If the layer config changed we need to validateDisplay() even if |
| // we're going to drop the frame, to flush the Composer object's |
| // internal command buffer and apply our layer changes. |
| Validate(HWC_DISPLAY_PRIMARY); |
| } |
| continue; |
| } |
| } |
| } |
| |
| PostLayers(); |
| } |
| } |
| |
| // Checks for changes in the surface stack and updates the layer config to |
| // accomodate the new stack. |
| bool HardwareComposer::UpdateLayerConfig() { |
| std::vector<std::shared_ptr<DirectDisplaySurface>> surfaces; |
| { |
| std::unique_lock<std::mutex> lock(post_thread_mutex_); |
| if (pending_surfaces_.empty()) |
| return false; |
| |
| surfaces = std::move(pending_surfaces_); |
| } |
| |
| ATRACE_NAME("UpdateLayerConfig_HwLayers"); |
| |
| display_surfaces_.clear(); |
| |
| Layer* target_layer; |
| size_t layer_index; |
| for (layer_index = 0; |
| layer_index < std::min(surfaces.size(), kMaxHardwareLayers); |
| layer_index++) { |
| // The bottom layer is opaque, other layers blend. |
| HWC::BlendMode blending = |
| layer_index == 0 ? HWC::BlendMode::None : HWC::BlendMode::Coverage; |
| layers_[layer_index].Setup(surfaces[layer_index], blending, |
| display_transform_, HWC::Composition::Device, |
| layer_index); |
| display_surfaces_.push_back(surfaces[layer_index]); |
| } |
| |
| // Clear unused layers. |
| for (size_t i = layer_index; i < kMaxHardwareLayers; i++) |
| layers_[i].Reset(); |
| |
| active_layer_count_ = layer_index; |
| ALOGD_IF(TRACE, "HardwareComposer::UpdateLayerConfig: %zd active layers", |
| active_layer_count_); |
| |
| // Any surfaces left over could not be assigned a hardware layer and will |
| // not be displayed. |
| ALOGW_IF(surfaces.size() != display_surfaces_.size(), |
| "HardwareComposer::UpdateLayerConfig: More surfaces than layers: " |
| "pending_surfaces=%zu display_surfaces=%zu", |
| surfaces.size(), display_surfaces_.size()); |
| |
| return true; |
| } |
| |
| void HardwareComposer::SetVSyncCallback(VSyncCallback callback) { |
| vsync_callback_ = callback; |
| } |
| |
| void HardwareComposer::HwcRefresh(hwc2_callback_data_t /*data*/, |
| hwc2_display_t /*display*/) { |
| // TODO(eieio): implement invalidate callbacks. |
| } |
| |
| void HardwareComposer::HwcVSync(hwc2_callback_data_t /*data*/, |
| hwc2_display_t /*display*/, |
| int64_t /*timestamp*/) { |
| ATRACE_NAME(__PRETTY_FUNCTION__); |
| // Intentionally empty. HWC may require a callback to be set to enable vsync |
| // signals. We bypass this callback thread by monitoring the vsync event |
| // directly, but signals still need to be enabled. |
| } |
| |
| void HardwareComposer::HwcHotplug(hwc2_callback_data_t /*callbackData*/, |
| hwc2_display_t /*display*/, |
| hwc2_connection_t /*connected*/) { |
| // TODO(eieio): implement display hotplug callbacks. |
| } |
| |
| void HardwareComposer::OnHardwareComposerRefresh() { |
| // TODO(steventhomas): Handle refresh. |
| } |
| |
| void HardwareComposer::SetBacklightBrightness(int brightness) { |
| if (backlight_brightness_fd_) { |
| std::array<char, 32> text; |
| const int length = snprintf(text.data(), text.size(), "%d", brightness); |
| write(backlight_brightness_fd_.Get(), text.data(), length); |
| } |
| } |
| |
| void Layer::InitializeGlobals(Hwc2::Composer* hwc2_hidl, |
| const HWCDisplayMetrics* metrics) { |
| hwc2_hidl_ = hwc2_hidl; |
| display_metrics_ = metrics; |
| } |
| |
| void Layer::Reset() { |
| if (hwc2_hidl_ != nullptr && hardware_composer_layer_) { |
| hwc2_hidl_->destroyLayer(HWC_DISPLAY_PRIMARY, hardware_composer_layer_); |
| hardware_composer_layer_ = 0; |
| } |
| |
| z_order_ = 0; |
| blending_ = HWC::BlendMode::None; |
| transform_ = HWC::Transform::None; |
| composition_type_ = HWC::Composition::Invalid; |
| target_composition_type_ = composition_type_; |
| source_ = EmptyVariant{}; |
| acquire_fence_.Close(); |
| surface_rect_functions_applied_ = false; |
| } |
| |
| void Layer::Setup(const std::shared_ptr<DirectDisplaySurface>& surface, |
| HWC::BlendMode blending, HWC::Transform transform, |
| HWC::Composition composition_type, size_t z_order) { |
| Reset(); |
| z_order_ = z_order; |
| blending_ = blending; |
| transform_ = transform; |
| composition_type_ = HWC::Composition::Invalid; |
| target_composition_type_ = composition_type; |
| source_ = SourceSurface{surface}; |
| CommonLayerSetup(); |
| } |
| |
| void Layer::Setup(const std::shared_ptr<IonBuffer>& buffer, |
| HWC::BlendMode blending, HWC::Transform transform, |
| HWC::Composition composition_type, size_t z_order) { |
| Reset(); |
| z_order_ = z_order; |
| blending_ = blending; |
| transform_ = transform; |
| composition_type_ = HWC::Composition::Invalid; |
| target_composition_type_ = composition_type; |
| source_ = SourceBuffer{buffer}; |
| CommonLayerSetup(); |
| } |
| |
| void Layer::UpdateBuffer(const std::shared_ptr<IonBuffer>& buffer) { |
| if (source_.is<SourceBuffer>()) |
| std::get<SourceBuffer>(source_) = {buffer}; |
| } |
| |
| void Layer::SetBlending(HWC::BlendMode blending) { blending_ = blending; } |
| void Layer::SetZOrder(size_t z_order) { z_order_ = z_order; } |
| |
| 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::UpdateLayerSettings() { |
| if (!IsLayerSetup()) { |
| ALOGE( |
| "HardwareComposer::Layer::UpdateLayerSettings: Attempt to update " |
| "unused Layer!"); |
| return; |
| } |
| |
| HWC::Error error; |
| hwc2_display_t display = HWC_DISPLAY_PRIMARY; |
| |
| error = hwc2_hidl_->setLayerCompositionType( |
| display, hardware_composer_layer_, |
| composition_type_.cast<Hwc2::IComposerClient::Composition>()); |
| ALOGE_IF( |
| error != HWC::Error::None, |
| "Layer::UpdateLayerSettings: Error setting layer composition type: %s", |
| error.to_string().c_str()); |
| |
| error = hwc2_hidl_->setLayerBlendMode( |
| display, 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()); |
| |
| // TODO(eieio): Use surface attributes or some other mechanism to control |
| // the layer display frame. |
| error = hwc2_hidl_->setLayerDisplayFrame( |
| display, hardware_composer_layer_, |
| {0, 0, display_metrics_->width, display_metrics_->height}); |
| ALOGE_IF(error != HWC::Error::None, |
| "Layer::UpdateLayerSettings: Error setting layer display frame: %s", |
| error.to_string().c_str()); |
| |
| error = hwc2_hidl_->setLayerVisibleRegion( |
| display, hardware_composer_layer_, |
| {{0, 0, display_metrics_->width, display_metrics_->height}}); |
| ALOGE_IF(error != HWC::Error::None, |
| "Layer::UpdateLayerSettings: Error setting layer visible region: %s", |
| error.to_string().c_str()); |
| |
| error = |
| hwc2_hidl_->setLayerPlaneAlpha(display, hardware_composer_layer_, 1.0f); |
| ALOGE_IF(error != HWC::Error::None, |
| "Layer::UpdateLayerSettings: Error setting layer plane alpha: %s", |
| error.to_string().c_str()); |
| |
| error = |
| hwc2_hidl_->setLayerZOrder(display, 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::CommonLayerSetup() { |
| HWC::Error error = |
| hwc2_hidl_->createLayer(HWC_DISPLAY_PRIMARY, &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(); |
| } |
| |
| void Layer::Prepare() { |
| int right, bottom; |
| sp<GraphicBuffer> handle; |
| |
| // Acquire the next buffer according to the type of source. |
| IfAnyOf<SourceSurface, SourceBuffer>::Call(&source_, [&](auto& source) { |
| std::tie(right, bottom, handle, acquire_fence_) = source.Acquire(); |
| }); |
| |
| // 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; |
| hwc2_hidl_->setLayerCompositionType( |
| HWC_DISPLAY_PRIMARY, hardware_composer_layer_, |
| composition_type_.cast<Hwc2::IComposerClient::Composition>()); |
| Hwc2::IComposerClient::Color layer_color = {0, 0, 0, 0}; |
| hwc2_hidl_->setLayerColor(HWC_DISPLAY_PRIMARY, 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_; |
| hwc2_hidl_->setLayerCompositionType( |
| HWC_DISPLAY_PRIMARY, hardware_composer_layer_, |
| composition_type_.cast<Hwc2::IComposerClient::Composition>()); |
| } |
| |
| HWC::Error error{HWC::Error::None}; |
| error = hwc2_hidl_->setLayerBuffer(HWC_DISPLAY_PRIMARY, |
| hardware_composer_layer_, 0, 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 = hwc2_hidl_->setLayerSourceCrop(HWC_DISPLAY_PRIMARY, |
| 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 |