From: Sean Paul <seanpaul@xxxxxxxxxxxx> Since HWC2 doesn't require the use of threads to implement correct synchronization, remove some of these threads. Signed-off-by: Robert Foss <robert.foss@xxxxxxxxxxxxx> --- Android.mk | 3 - drmcomposition.cpp | 166 ---------------------------------------- drmcomposition.h | 79 ------------------- drmcompositor.cpp | 106 -------------------------- drmcompositor.h | 56 -------------- drmcompositorworker.h | 41 ---------- drmdisplaycomposition.cpp | 1 + drmdisplaycomposition.h | 10 +++ drmdisplaycompositor.cpp | 189 ++++------------------------------------------ drmdisplaycompositor.h | 36 +-------- drmeventlistener.cpp | 3 + drmhwctwo.cpp | 6 +- drmresources.cpp | 54 +------------ drmresources.h | 5 -- glworker.cpp | 52 +++++++++++-- glworker.h | 10 +++ 16 files changed, 93 insertions(+), 724 deletions(-) delete mode 100644 drmcomposition.cpp delete mode 100644 drmcomposition.h delete mode 100644 drmcompositor.cpp delete mode 100644 drmcompositor.h delete mode 100644 drmcompositorworker.h diff --git a/Android.mk b/Android.mk index aa95b44..5d16c2f 100644 --- a/Android.mk +++ b/Android.mk @@ -57,9 +57,6 @@ LOCAL_C_INCLUDES := \ LOCAL_SRC_FILES := \ autolock.cpp \ drmresources.cpp \ - drmcomposition.cpp \ - drmcompositor.cpp \ - drmcompositorworker.cpp \ drmconnector.cpp \ drmcrtc.cpp \ drmdisplaycomposition.cpp \ diff --git a/drmcomposition.cpp b/drmcomposition.cpp deleted file mode 100644 index 1aaf920..0000000 --- a/drmcomposition.cpp +++ /dev/null @@ -1,166 +0,0 @@ -/* - * Copyright (C) 2015 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#define LOG_TAG "hwc-drm-composition" - -#include "drmcomposition.h" -#include "drmcrtc.h" -#include "drmplane.h" -#include "drmresources.h" -#include "platform.h" - -#include <stdlib.h> - -#include <cutils/log.h> -#include <cutils/properties.h> -#include <sw_sync.h> -#include <sync/sync.h> - -namespace android { - -DrmComposition::DrmComposition(DrmResources *drm, Importer *importer, - Planner *planner) - : drm_(drm), importer_(importer), planner_(planner) { - char use_overlay_planes_prop[PROPERTY_VALUE_MAX]; - property_get("hwc.drm.use_overlay_planes", use_overlay_planes_prop, "1"); - bool use_overlay_planes = atoi(use_overlay_planes_prop); - - for (auto &plane : drm->planes()) { - if (plane->type() == DRM_PLANE_TYPE_PRIMARY) - primary_planes_.push_back(plane.get()); - else if (use_overlay_planes && plane->type() == DRM_PLANE_TYPE_OVERLAY) - overlay_planes_.push_back(plane.get()); - } -} - -int DrmComposition::Init(uint64_t frame_no) { - for (auto &conn : drm_->connectors()) { - int display = conn->display(); - composition_map_[display].reset(new DrmDisplayComposition()); - if (!composition_map_[display]) { - ALOGE("Failed to allocate new display composition\n"); - return -ENOMEM; - } - - // If the display hasn't been modeset yet, this will be NULL - DrmCrtc *crtc = drm_->GetCrtcForDisplay(display); - - int ret = composition_map_[display]->Init(drm_, crtc, importer_, planner_, - frame_no); - if (ret) { - ALOGE("Failed to init display composition for %d", display); - return ret; - } - } - return 0; -} - -int DrmComposition::SetLayers(size_t num_displays, - DrmCompositionDisplayLayersMap *maps) { - int ret = 0; - for (size_t display_index = 0; display_index < num_displays; - display_index++) { - DrmCompositionDisplayLayersMap &map = maps[display_index]; - int display = map.display; - - if (!drm_->GetConnectorForDisplay(display)) { - ALOGE("Invalid display given to SetLayers %d", display); - continue; - } - - ret = composition_map_[display]->SetLayers( - map.layers.data(), map.layers.size(), map.geometry_changed); - if (ret) - return ret; - } - - return 0; -} - -int DrmComposition::SetDpmsMode(int display, uint32_t dpms_mode) { - return composition_map_[display]->SetDpmsMode(dpms_mode); -} - -int DrmComposition::SetDisplayMode(int display, const DrmMode &display_mode) { - return composition_map_[display]->SetDisplayMode(display_mode); -} - -std::unique_ptr<DrmDisplayComposition> DrmComposition::TakeDisplayComposition( - int display) { - return std::move(composition_map_[display]); -} - -int DrmComposition::Plan(std::map<int, DrmDisplayCompositor> &compositor_map) { - int ret = 0; - for (auto &conn : drm_->connectors()) { - int display = conn->display(); - DrmDisplayComposition *comp = GetDisplayComposition(display); - ret = comp->Plan(compositor_map[display].squash_state(), &primary_planes_, - &overlay_planes_); - if (ret) { - ALOGE("Failed to plan composition for dislay %d", display); - return ret; - } - } - - return 0; -} - -int DrmComposition::DisableUnusedPlanes() { - for (auto &conn : drm_->connectors()) { - int display = conn->display(); - DrmDisplayComposition *comp = GetDisplayComposition(display); - - /* - * Leave empty compositions alone - * TODO: re-visit this and potentially disable leftover planes after the - * active compositions have gobbled up all they can - */ - if (comp->type() == DRM_COMPOSITION_TYPE_EMPTY || - comp->type() == DRM_COMPOSITION_TYPE_MODESET) - continue; - - DrmCrtc *crtc = drm_->GetCrtcForDisplay(display); - if (!crtc) { - ALOGE("Failed to find crtc for display %d", display); - continue; - } - - for (std::vector<DrmPlane *>::iterator iter = primary_planes_.begin(); - iter != primary_planes_.end(); ++iter) { - if ((*iter)->GetCrtcSupported(*crtc)) { - comp->AddPlaneDisable(*iter); - primary_planes_.erase(iter); - break; - } - } - for (std::vector<DrmPlane *>::iterator iter = overlay_planes_.begin(); - iter != overlay_planes_.end();) { - if ((*iter)->GetCrtcSupported(*crtc)) { - comp->AddPlaneDisable(*iter); - iter = overlay_planes_.erase(iter); - } else { - iter++; - } - } - } - return 0; -} - -DrmDisplayComposition *DrmComposition::GetDisplayComposition(int display) { - return composition_map_[display].get(); -} -} diff --git a/drmcomposition.h b/drmcomposition.h deleted file mode 100644 index eae8cde..0000000 --- a/drmcomposition.h +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Copyright (C) 2015 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. - */ - -#ifndef ANDROID_DRM_COMPOSITION_H_ -#define ANDROID_DRM_COMPOSITION_H_ - -#include "drmhwcomposer.h" -#include "drmdisplaycomposition.h" -#include "drmplane.h" -#include "platform.h" - -#include <map> -#include <vector> - -#include <hardware/hardware.h> -#include <hardware/hwcomposer.h> - -namespace android { - -class DrmDisplayCompositor; - -struct DrmCompositionDisplayLayersMap { - int display; - bool geometry_changed = true; - std::vector<DrmHwcLayer> layers; - - DrmCompositionDisplayLayersMap() = default; - DrmCompositionDisplayLayersMap(DrmCompositionDisplayLayersMap &&rhs) = - default; -}; - -class DrmComposition { - public: - DrmComposition(DrmResources *drm, Importer *importer, Planner *planner); - - int Init(uint64_t frame_no); - - int SetLayers(size_t num_displays, DrmCompositionDisplayLayersMap *maps); - int SetDpmsMode(int display, uint32_t dpms_mode); - int SetDisplayMode(int display, const DrmMode &display_mode); - - std::unique_ptr<DrmDisplayComposition> TakeDisplayComposition(int display); - DrmDisplayComposition *GetDisplayComposition(int display); - - int Plan(std::map<int, DrmDisplayCompositor> &compositor_map); - int DisableUnusedPlanes(); - - private: - DrmComposition(const DrmComposition &) = delete; - - DrmResources *drm_; - Importer *importer_; - Planner *planner_; - - std::vector<DrmPlane *> primary_planes_; - std::vector<DrmPlane *> overlay_planes_; - - /* - * This _must_ be read-only after it's passed to QueueComposition. Otherwise - * locking is required to maintain consistency across the compositor threads. - */ - std::map<int, std::unique_ptr<DrmDisplayComposition>> composition_map_; -}; -} - -#endif // ANDROID_DRM_COMPOSITION_H_ diff --git a/drmcompositor.cpp b/drmcompositor.cpp deleted file mode 100644 index c1f3ed8..0000000 --- a/drmcompositor.cpp +++ /dev/null @@ -1,106 +0,0 @@ -/* - * Copyright (C) 2015 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#define LOG_TAG "hwc-drm-compositor" - -#include "drmcompositor.h" -#include "drmdisplaycompositor.h" -#include "drmresources.h" -#include "platform.h" - -#include <sstream> -#include <stdlib.h> - -#include <cutils/log.h> - -namespace android { - -DrmCompositor::DrmCompositor(DrmResources *drm) : drm_(drm), frame_no_(0) { -} - -DrmCompositor::~DrmCompositor() { -} - -int DrmCompositor::Init() { - for (auto &conn : drm_->connectors()) { - int display = conn->display(); - int ret = compositor_map_[display].Init(drm_, display); - if (ret) { - ALOGE("Failed to initialize display compositor for %d", display); - return ret; - } - } - planner_ = Planner::CreateInstance(drm_); - if (!planner_) { - ALOGE("Failed to create planner instance for composition"); - return -ENOMEM; - } - - return 0; -} - -std::unique_ptr<DrmComposition> DrmCompositor::CreateComposition( - Importer *importer) { - std::unique_ptr<DrmComposition> composition( - new DrmComposition(drm_, importer, planner_.get())); - int ret = composition->Init(++frame_no_); - if (ret) { - ALOGE("Failed to initialize drm composition %d", ret); - return nullptr; - } - return composition; -} - -int DrmCompositor::QueueComposition( - std::unique_ptr<DrmComposition> composition) { - int ret; - - ret = composition->Plan(compositor_map_); - if (ret) - return ret; - - ret = composition->DisableUnusedPlanes(); - if (ret) - return ret; - - for (auto &conn : drm_->connectors()) { - int display = conn->display(); - int ret = compositor_map_[display].QueueComposition( - composition->TakeDisplayComposition(display)); - if (ret) { - ALOGE("Failed to queue composition for display %d (%d)", display, ret); - return ret; - } - } - - return 0; -} - -int DrmCompositor::Composite() { - /* - * This shouldn't be called, we should be calling Composite() on the display - * compositors directly. - */ - ALOGE("Calling base drm compositor Composite() function"); - return -EINVAL; -} - -void DrmCompositor::Dump(std::ostringstream *out) const { - *out << "DrmCompositor stats:\n"; - for (auto &conn : drm_->connectors()) - compositor_map_[conn->display()].Dump(out); -} -} diff --git a/drmcompositor.h b/drmcompositor.h deleted file mode 100644 index 19271b5..0000000 --- a/drmcompositor.h +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright (C) 2015 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. - */ - -#ifndef ANDROID_DRM_COMPOSITOR_H_ -#define ANDROID_DRM_COMPOSITOR_H_ - -#include "drmcomposition.h" -#include "drmdisplaycompositor.h" -#include "platform.h" - -#include <map> -#include <memory> -#include <sstream> - -namespace android { - -class DrmCompositor { - public: - DrmCompositor(DrmResources *drm); - ~DrmCompositor(); - - int Init(); - - std::unique_ptr<DrmComposition> CreateComposition(Importer *importer); - - int QueueComposition(std::unique_ptr<DrmComposition> composition); - int Composite(); - void Dump(std::ostringstream *out) const; - - private: - DrmCompositor(const DrmCompositor &) = delete; - - DrmResources *drm_; - std::unique_ptr<Planner> planner_; - - uint64_t frame_no_; - - // mutable for Dump() propagation - mutable std::map<int, DrmDisplayCompositor> compositor_map_; -}; -} - -#endif // ANDROID_DRM_COMPOSITOR_H_ diff --git a/drmcompositorworker.h b/drmcompositorworker.h deleted file mode 100644 index 731bc65..0000000 --- a/drmcompositorworker.h +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (C) 2015 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. - */ - -#ifndef ANDROID_DRM_COMPOSITOR_WORKER_H_ -#define ANDROID_DRM_COMPOSITOR_WORKER_H_ - -#include "worker.h" - -namespace android { - -class DrmDisplayCompositor; - -class DrmCompositorWorker : public Worker { - public: - DrmCompositorWorker(DrmDisplayCompositor *compositor); - ~DrmCompositorWorker() override; - - int Init(); - - protected: - void Routine() override; - - DrmDisplayCompositor *compositor_; - bool did_squash_all_ = false; -}; -} - -#endif diff --git a/drmdisplaycomposition.cpp b/drmdisplaycomposition.cpp index 0f8084b..66e67a4 100644 --- a/drmdisplaycomposition.cpp +++ b/drmdisplaycomposition.cpp @@ -17,6 +17,7 @@ #define LOG_TAG "hwc-drm-display-composition" #include "drmdisplaycomposition.h" +#include "drmdisplaycompositor.h" #include "drmcrtc.h" #include "drmplane.h" #include "drmresources.h" diff --git a/drmdisplaycomposition.h b/drmdisplaycomposition.h index 13da19d..b165adc 100644 --- a/drmdisplaycomposition.h +++ b/drmdisplaycomposition.h @@ -42,6 +42,16 @@ enum DrmCompositionType { DRM_COMPOSITION_TYPE_MODESET, }; +struct DrmCompositionDisplayLayersMap { + int display; + bool geometry_changed = true; + std::vector<DrmHwcLayer> layers; + + DrmCompositionDisplayLayersMap() = default; + DrmCompositionDisplayLayersMap(DrmCompositionDisplayLayersMap &&rhs) = + default; +}; + struct DrmCompositionRegion { DrmHwcRect<int> frame; std::vector<size_t> source_layers; diff --git a/drmdisplaycompositor.cpp b/drmdisplaycompositor.cpp index a1baed1..bd670cf 100644 --- a/drmdisplaycompositor.cpp +++ b/drmdisplaycompositor.cpp @@ -37,8 +37,6 @@ #include "drmresources.h" #include "glworker.h" -#define DRM_DISPLAY_COMPOSITOR_MAX_QUEUE_DEPTH 2 - namespace android { void SquashState::Init(DrmHwcLayer *layers, size_t num_layers) { @@ -176,58 +174,9 @@ static bool UsesSquash(const std::vector<DrmCompositionPlane> &comp_planes) { }); } -DrmDisplayCompositor::FrameWorker::FrameWorker(DrmDisplayCompositor *compositor) - : Worker("frame-worker", HAL_PRIORITY_URGENT_DISPLAY), - compositor_(compositor) { -} - -DrmDisplayCompositor::FrameWorker::~FrameWorker() { -} - -int DrmDisplayCompositor::FrameWorker::Init() { - return InitWorker(); -} - -void DrmDisplayCompositor::FrameWorker::QueueFrame( - std::unique_ptr<DrmDisplayComposition> composition, int status) { - Lock(); - FrameState frame; - frame.composition = std::move(composition); - frame.status = status; - frame_queue_.push(std::move(frame)); - Unlock(); - Signal(); -} - -void DrmDisplayCompositor::FrameWorker::Routine() { - int wait_ret = 0; - - Lock(); - if (frame_queue_.empty()) { - wait_ret = WaitForSignalOrExitLocked(); - } - - FrameState frame; - if (!frame_queue_.empty()) { - frame = std::move(frame_queue_.front()); - frame_queue_.pop(); - } - Unlock(); - - if (wait_ret == -EINTR) { - return; - } else if (wait_ret) { - ALOGE("Failed to wait for signal, %d", wait_ret); - return; - } - compositor_->ApplyFrame(std::move(frame.composition), frame.status); -} - DrmDisplayCompositor::DrmDisplayCompositor() : drm_(NULL), display_(-1), - worker_(this), - frame_worker_(this), initialized_(false), active_(false), use_hw_overlays_(true), @@ -245,9 +194,6 @@ DrmDisplayCompositor::~DrmDisplayCompositor() { if (!initialized_) return; - worker_.Exit(); - frame_worker_.Exit(); - int ret = pthread_mutex_lock(&lock_); if (ret) ALOGE("Failed to acquire compositor lock %d", ret); @@ -257,10 +203,6 @@ DrmDisplayCompositor::~DrmDisplayCompositor() { if (mode_.old_blob_id) drm_->DestroyPropertyBlob(mode_.old_blob_id); - while (!composite_queue_.empty()) { - composite_queue_.front().reset(); - composite_queue_.pop(); - } active_composition_.reset(); ret = pthread_mutex_unlock(&lock_); @@ -279,18 +221,6 @@ int DrmDisplayCompositor::Init(DrmResources *drm, int display) { ALOGE("Failed to initialize drm compositor lock %d\n", ret); return ret; } - ret = worker_.Init(); - if (ret) { - pthread_mutex_destroy(&lock_); - ALOGE("Failed to initialize compositor worker %d\n", ret); - return ret; - } - ret = frame_worker_.Init(); - if (ret) { - pthread_mutex_destroy(&lock_); - ALOGE("Failed to initialize frame worker %d\n", ret); - return ret; - } initialized_ = true; return 0; @@ -301,55 +231,6 @@ std::unique_ptr<DrmDisplayComposition> DrmDisplayCompositor::CreateComposition() return std::unique_ptr<DrmDisplayComposition>(new DrmDisplayComposition()); } -int DrmDisplayCompositor::QueueComposition( - std::unique_ptr<DrmDisplayComposition> composition) { - switch (composition->type()) { - case DRM_COMPOSITION_TYPE_FRAME: - if (!active_) - return -ENODEV; - break; - case DRM_COMPOSITION_TYPE_DPMS: - /* - * Update the state as soon as we get it so we can start/stop queuing - * frames asap. - */ - active_ = (composition->dpms_mode() == DRM_MODE_DPMS_ON); - break; - case DRM_COMPOSITION_TYPE_MODESET: - break; - case DRM_COMPOSITION_TYPE_EMPTY: - return 0; - default: - ALOGE("Unknown composition type %d/%d", composition->type(), display_); - return -ENOENT; - } - - int ret = pthread_mutex_lock(&lock_); - if (ret) { - ALOGE("Failed to acquire compositor lock %d", ret); - return ret; - } - - // Block the queue if it gets too large. Otherwise, SurfaceFlinger will start - // to eat our buffer handles when we get about 1 second behind. - while (composite_queue_.size() >= DRM_DISPLAY_COMPOSITOR_MAX_QUEUE_DEPTH) { - pthread_mutex_unlock(&lock_); - sched_yield(); - pthread_mutex_lock(&lock_); - } - - composite_queue_.push(std::move(composition)); - - ret = pthread_mutex_unlock(&lock_); - if (ret) { - ALOGE("Failed to release compositor lock %d", ret); - return ret; - } - - worker_.Signal(); - return 0; -} - std::tuple<uint32_t, uint32_t, int> DrmDisplayCompositor::GetActiveModeResolution() { DrmConnector *connector = drm_->GetConnectorForDisplay(display_); @@ -514,6 +395,15 @@ int DrmDisplayCompositor::PrepareFrame(DrmDisplayComposition *display_comp) { std::vector<DrmCompositionRegion> &pre_comp_regions = display_comp->pre_comp_regions(); + if (!pre_compositor_) { + pre_compositor_.reset(new GLWorkerCompositor()); + int ret = pre_compositor_->Init(); + if (ret) { + ALOGE("Failed to initialize OpenGL compositor %d", ret); + return ret; + } + } + int squash_layer_index = -1; if (squash_regions.size() > 0) { squash_framebuffer_index_ = (squash_framebuffer_index_ + 1) % 2; @@ -906,41 +796,9 @@ void DrmDisplayCompositor::ApplyFrame( ALOGE("Failed to release lock for active_composition swap"); } -int DrmDisplayCompositor::Composite() { - ATRACE_CALL(); - - if (!pre_compositor_) { - pre_compositor_.reset(new GLWorkerCompositor()); - int ret = pre_compositor_->Init(); - if (ret) { - ALOGE("Failed to initialize OpenGL compositor %d", ret); - return ret; - } - } - - int ret = pthread_mutex_lock(&lock_); - if (ret) { - ALOGE("Failed to acquire compositor lock %d", ret); - return ret; - } - if (composite_queue_.empty()) { - ret = pthread_mutex_unlock(&lock_); - if (ret) - ALOGE("Failed to release compositor lock %d", ret); - return ret; - } - - std::unique_ptr<DrmDisplayComposition> composition( - std::move(composite_queue_.front())); - - composite_queue_.pop(); - - ret = pthread_mutex_unlock(&lock_); - if (ret) { - ALOGE("Failed to release compositor lock %d", ret); - return ret; - } - +int DrmDisplayCompositor::ApplyComposition( + std::unique_ptr<DrmDisplayComposition> composition) { + int ret = 0; switch (composition->type()) { case DRM_COMPOSITION_TYPE_FRAME: ret = PrepareFrame(composition.get()); @@ -959,7 +817,7 @@ int DrmDisplayCompositor::Composite() { } // If use_hw_overlays_ is false, we can't use hardware to composite the - // frame. So squash all layers into a single composition and queue that + // frame. So squash all layers into a single composition and apply that // instead. if (!use_hw_overlays_) { std::unique_ptr<DrmDisplayComposition> squashed = CreateComposition(); @@ -975,9 +833,10 @@ int DrmDisplayCompositor::Composite() { return ret; } } - frame_worker_.QueueFrame(std::move(composition), ret); + ApplyFrame(std::move(composition), ret); break; case DRM_COMPOSITION_TYPE_DPMS: + active_ = (composition->dpms_mode() == DRM_MODE_DPMS_ON); ret = ApplyDpms(composition.get()); if (ret) ALOGE("Failed to apply dpms for display %d", display_); @@ -1001,24 +860,6 @@ int DrmDisplayCompositor::Composite() { return ret; } -bool DrmDisplayCompositor::HaveQueuedComposites() const { - int ret = pthread_mutex_lock(&lock_); - if (ret) { - ALOGE("Failed to acquire compositor lock %d", ret); - return false; - } - - bool empty_ret = !composite_queue_.empty(); - - ret = pthread_mutex_unlock(&lock_); - if (ret) { - ALOGE("Failed to release compositor lock %d", ret); - return false; - } - - return empty_ret; -} - int DrmDisplayCompositor::SquashAll() { AutoLock lock(&lock_, "compositor"); int ret = lock.Lock(); diff --git a/drmdisplaycompositor.h b/drmdisplaycompositor.h index 9487cac..f1965fb 100644 --- a/drmdisplaycompositor.h +++ b/drmdisplaycompositor.h @@ -18,14 +18,12 @@ #define ANDROID_DRM_DISPLAY_COMPOSITOR_H_ #include "drmhwcomposer.h" -#include "drmcomposition.h" -#include "drmcompositorworker.h" +#include "drmdisplaycomposition.h" #include "drmframebuffer.h" #include "separate_rects.h" #include <pthread.h> #include <memory> -#include <queue> #include <sstream> #include <tuple> @@ -89,42 +87,18 @@ class DrmDisplayCompositor { int Init(DrmResources *drm, int display); std::unique_ptr<DrmDisplayComposition> CreateComposition() const; - int QueueComposition(std::unique_ptr<DrmDisplayComposition> composition); + int ApplyComposition(std::unique_ptr<DrmDisplayComposition> composition); int Composite(); int SquashAll(); void Dump(std::ostringstream *out) const; std::tuple<uint32_t, uint32_t, int> GetActiveModeResolution(); - bool HaveQueuedComposites() const; - SquashState *squash_state() { return &squash_state_; } private: - struct FrameState { - std::unique_ptr<DrmDisplayComposition> composition; - int status = 0; - }; - - class FrameWorker : public Worker { - public: - FrameWorker(DrmDisplayCompositor *compositor); - ~FrameWorker() override; - - int Init(); - void QueueFrame(std::unique_ptr<DrmDisplayComposition> composition, - int status); - - protected: - void Routine() override; - - private: - DrmDisplayCompositor *compositor_; - std::queue<FrameState> frame_queue_; - }; - struct ModeState { bool needs_modeset = false; DrmMode mode; @@ -158,10 +132,6 @@ class DrmDisplayCompositor { DrmResources *drm_; int display_; - DrmCompositorWorker worker_; - FrameWorker frame_worker_; - - std::queue<std::unique_ptr<DrmDisplayComposition>> composite_queue_; std::unique_ptr<DrmDisplayComposition> active_composition_; bool initialized_; @@ -178,7 +148,7 @@ class DrmDisplayCompositor { int squash_framebuffer_index_; DrmFramebuffer squash_framebuffers_[2]; - // mutable since we need to acquire in HaveQueuedComposites + // mutable since we need to acquire in Dump() mutable pthread_mutex_t lock_; // State tracking progress since our last Dump(). These are mutable since diff --git a/drmeventlistener.cpp b/drmeventlistener.cpp index 0514aa6..984d1dd 100644 --- a/drmeventlistener.cpp +++ b/drmeventlistener.cpp @@ -20,10 +20,13 @@ #include "drmresources.h" #include <assert.h> +#include <errno.h> #include <linux/netlink.h> #include <sys/socket.h> #include <cutils/log.h> +#include <hardware/hardware.h> +#include <hardware/hwcomposer.h> #include <xf86drm.h> namespace android { diff --git a/drmhwctwo.cpp b/drmhwctwo.cpp index 8c853f4..762ee8c 100644 --- a/drmhwctwo.cpp +++ b/drmhwctwo.cpp @@ -557,7 +557,7 @@ HWC2::Error DrmHwcTwo::HwcDisplay::PresentDisplay(int32_t *retire_fence) { i = overlay_planes.erase(i); } - ret = compositor_.QueueComposition(std::move(composition)); + ret = compositor_.ApplyComposition(std::move(composition)); if (ret) { ALOGE("Failed to apply the frame composition ret=%d", ret); return HWC2::Error::BadParameter; @@ -593,7 +593,7 @@ HWC2::Error DrmHwcTwo::HwcDisplay::SetActiveConfig(hwc2_config_t config) { compositor_.CreateComposition(); composition->Init(drm_, crtc_, importer_.get(), planner_.get(), frame_no_); int ret = composition->SetDisplayMode(*mode); - ret = compositor_.QueueComposition(std::move(composition)); + ret = compositor_.ApplyComposition(std::move(composition)); if (ret) { ALOGE("Failed to queue dpms composition on %d", ret); return HWC2::Error::BadConfig; @@ -673,7 +673,7 @@ HWC2::Error DrmHwcTwo::HwcDisplay::SetPowerMode(int32_t mode_in) { compositor_.CreateComposition(); composition->Init(drm_, crtc_, importer_.get(), planner_.get(), frame_no_); composition->SetDpmsMode(dpms_value); - int ret = compositor_.QueueComposition(std::move(composition)); + int ret = compositor_.ApplyComposition(std::move(composition)); if (ret) { ALOGE("Failed to apply the dpms composition ret=%d", ret); return HWC2::Error::BadParameter; diff --git a/drmresources.cpp b/drmresources.cpp index 6b8ed03..762f5ef 100644 --- a/drmresources.cpp +++ b/drmresources.cpp @@ -35,7 +35,7 @@ namespace android { -DrmResources::DrmResources() : compositor_(this), event_listener_(this) { +DrmResources::DrmResources() : event_listener_(this) { } DrmResources::~DrmResources() { @@ -201,10 +201,6 @@ int DrmResources::Init() { if (ret) return ret; - ret = compositor_.Init(); - if (ret) - return ret; - ret = event_listener_.Init(); if (ret) { ALOGE("Can't initialize event listener %d", ret); @@ -333,54 +329,6 @@ int DrmResources::DestroyPropertyBlob(uint32_t blob_id) { return 0; } -int DrmResources::SetDisplayActiveMode(int display, const DrmMode &mode) { - std::unique_ptr<DrmComposition> comp(compositor_.CreateComposition(NULL)); - if (!comp) { - ALOGE("Failed to create composition for dpms on %d", display); - return -ENOMEM; - } - int ret = comp->SetDisplayMode(display, mode); - if (ret) { - ALOGE("Failed to add mode to composition on %d %d", display, ret); - return ret; - } - ret = compositor_.QueueComposition(std::move(comp)); - if (ret) { - ALOGE("Failed to queue dpms composition on %d %d", display, ret); - return ret; - } - return 0; -} - -int DrmResources::SetDpmsMode(int display, uint64_t mode) { - if (mode != DRM_MODE_DPMS_ON && mode != DRM_MODE_DPMS_OFF) { - ALOGE("Invalid dpms mode %" PRIu64, mode); - return -EINVAL; - } - - std::unique_ptr<DrmComposition> comp(compositor_.CreateComposition(NULL)); - if (!comp) { - ALOGE("Failed to create composition for dpms on %d", display); - return -ENOMEM; - } - int ret = comp->SetDpmsMode(display, mode); - if (ret) { - ALOGE("Failed to add dpms %" PRIu64 " to composition on %d %d", mode, - display, ret); - return ret; - } - ret = compositor_.QueueComposition(std::move(comp)); - if (ret) { - ALOGE("Failed to queue dpms composition on %d %d", display, ret); - return ret; - } - return 0; -} - -DrmCompositor *DrmResources::compositor() { - return &compositor_; -} - DrmEventListener *DrmResources::event_listener() { return &event_listener_; } diff --git a/drmresources.h b/drmresources.h index 011f87e..a2d8d16 100644 --- a/drmresources.h +++ b/drmresources.h @@ -17,7 +17,6 @@ #ifndef ANDROID_DRM_H_ #define ANDROID_DRM_H_ -#include "drmcompositor.h" #include "drmconnector.h" #include "drmcrtc.h" #include "drmencoder.h" @@ -58,7 +57,6 @@ class DrmResources { DrmConnector *GetConnectorForDisplay(int display) const; DrmCrtc *GetCrtcForDisplay(int display) const; DrmPlane *GetPlane(uint32_t id) const; - DrmCompositor *compositor(); DrmEventListener *event_listener(); int GetPlaneProperty(const DrmPlane &plane, const char *prop_name, @@ -69,8 +67,6 @@ class DrmResources { DrmProperty *property); uint32_t next_mode_id(); - int SetDisplayActiveMode(int display, const DrmMode &mode); - int SetDpmsMode(int display, uint64_t mode); int CreatePropertyBlob(void *data, size_t length, uint32_t *blob_id); int DestroyPropertyBlob(uint32_t blob_id); @@ -89,7 +85,6 @@ class DrmResources { std::vector<std::unique_ptr<DrmEncoder>> encoders_; std::vector<std::unique_ptr<DrmCrtc>> crtcs_; std::vector<std::unique_ptr<DrmPlane>> planes_; - DrmCompositor compositor_; DrmEventListener event_listener_; std::pair<uint32_t, uint32_t> min_resolution_; diff --git a/glworker.cpp b/glworker.cpp index e12995e..e90576a 100644 --- a/glworker.cpp +++ b/glworker.cpp @@ -143,6 +143,38 @@ static bool HasExtension(const char *extension, const char *extensions) { return false; } +int GLWorkerCompositor::BeginContext() { + private_.saved_egl_display = eglGetCurrentDisplay(); + private_.saved_egl_ctx = eglGetCurrentContext(); + + if (private_.saved_egl_display != egl_display_ || + private_.saved_egl_ctx != egl_ctx_) { + private_.saved_egl_read = eglGetCurrentSurface(EGL_READ); + private_.saved_egl_draw = eglGetCurrentSurface(EGL_DRAW); + } else { + return 0; + } + + if (!eglMakeCurrent(egl_display_, EGL_NO_SURFACE, EGL_NO_SURFACE, egl_ctx_)) { + ALOGE("BeginContext failed: %s", GetEGLError()); + return 1; + } + return 0; +} + +int GLWorkerCompositor::EndContext() { + if (private_.saved_egl_display != eglGetCurrentDisplay() || + private_.saved_egl_ctx != eglGetCurrentContext()) { + if (!eglMakeCurrent(private_.saved_egl_display, private_.saved_egl_read, + private_.saved_egl_draw, private_.saved_egl_ctx)) { + ALOGE("EndContext failed: %s", GetEGLError()); + return 1; + } + } + + return 0; +} + static AutoGLShader CompileAndCheckShader(GLenum type, unsigned source_count, const GLchar **sources, std::ostringstream *shader_log) { @@ -508,10 +540,9 @@ int GLWorkerCompositor::Init() { return 1; } - if (!eglMakeCurrent(egl_display_, EGL_NO_SURFACE, EGL_NO_SURFACE, egl_ctx_)) { - ALOGE("Failed to make the OpenGL ES Context current: %s", GetEGLError()); - return 1; - } + ret = BeginContext(); + if (ret) + return ret; gl_extensions = (const char *)glGetString(GL_EXTENSIONS); @@ -530,6 +561,9 @@ int GLWorkerCompositor::Init() { std::ostringstream shader_log; blend_programs_.emplace_back(GenerateProgram(1, &shader_log)); + + EndContext(); + if (blend_programs_.back().get() == 0) { ALOGE("%s", shader_log.str().c_str()); return 1; @@ -558,12 +592,17 @@ int GLWorkerCompositor::Composite(DrmHwcLayer *layers, return -EALREADY; } + ret = BeginContext(); + if (ret) + return -1; + GLint frame_width = framebuffer->getWidth(); GLint frame_height = framebuffer->getHeight(); CachedFramebuffer *cached_framebuffer = PrepareAndCacheFramebuffer(framebuffer); if (cached_framebuffer == NULL) { ALOGE("Composite failed because of failed framebuffer"); + EndContext(); return -EINVAL; } @@ -597,8 +636,10 @@ int GLWorkerCompositor::Composite(DrmHwcLayer *layers, } } - if (ret) + if (ret) { + EndContext(); return ret; + } glViewport(0, 0, frame_width, frame_height); @@ -676,6 +717,7 @@ int GLWorkerCompositor::Composite(DrmHwcLayer *layers, glBindFramebuffer(GL_FRAMEBUFFER, 0); + EndContext(); return ret; } diff --git a/glworker.h b/glworker.h index 158490c..26de55d 100644 --- a/glworker.h +++ b/glworker.h @@ -64,6 +64,16 @@ class GLWorkerCompositor { bool Promote(); }; + struct { + EGLDisplay saved_egl_display = EGL_NO_DISPLAY; + EGLContext saved_egl_ctx = EGL_NO_CONTEXT; + EGLSurface saved_egl_read = EGL_NO_SURFACE; + EGLSurface saved_egl_draw = EGL_NO_SURFACE; + } private_; + + int BeginContext(); + int EndContext(); + CachedFramebuffer *FindCachedFramebuffer( const sp<GraphicBuffer> &framebuffer); CachedFramebuffer *PrepareAndCacheFramebuffer( -- 2.11.0 _______________________________________________ dri-devel mailing list dri-devel@xxxxxxxxxxxxxxxxxxxxx https://lists.freedesktop.org/mailman/listinfo/dri-devel
