1 /* 2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef RS_HARDWARE_THREAD_H 17 #define RS_HARDWARE_THREAD_H 18 19 #include <atomic> 20 #include <mutex> 21 22 #include "event_handler.h" 23 #include "hdi_backend.h" 24 #include "hgm_core.h" 25 #include "rs_main_thread.h" 26 #include "rs_vblank_idle_corrector.h" 27 #ifdef RES_SCHED_ENABLE 28 #include "vsync_system_ability_listener.h" 29 #endif 30 31 namespace OHOS::Rosen { 32 using UniFallbackCallback = std::function<void(const sptr<Surface>& surface, const std::vector<LayerInfoPtr>& layers, 33 uint32_t screenId)>; 34 using OutputPtr = std::shared_ptr<HdiOutput>; 35 using LayerPtr = std::shared_ptr<HdiLayer>; 36 class ScheduledTask; 37 38 struct RefreshRateParam { 39 uint32_t rate = 0; 40 uint64_t frameTimestamp = 0; 41 int64_t actualTimestamp = 0; 42 uint64_t vsyncId = 0; 43 uint64_t constraintRelativeTime = 0; 44 bool isForceRefresh = false; 45 }; 46 47 class RSHardwareThread { 48 public: 49 static RSHardwareThread& Instance(); 50 void Start(); 51 void PostTask(const std::function<void()>& task); 52 void PostDelayTask(const std::function<void()>& task, int64_t delayTime); 53 void CommitAndReleaseLayers(OutputPtr output, const std::vector<LayerInfoPtr>& layers); 54 template<typename Task, typename Return = std::invoke_result_t<Task>> ScheduleTask(Task && task)55 std::future<Return> ScheduleTask(Task&& task) 56 { 57 auto [scheduledTask, taskFuture] = Detail::ScheduledTask<Task>::Create(std::forward<Task&&>(task)); 58 PostTask([t(std::move(scheduledTask))]() { t->Run(); }); 59 return std::move(taskFuture); 60 } 61 uint32_t GetunExecuteTaskNum(); 62 void RefreshRateCounts(std::string& dumpString); 63 void ClearRefreshRateCounts(std::string& dumpString); 64 int GetHardwareTid() const; 65 GSError ClearFrameBuffers(OutputPtr output); 66 void OnScreenVBlankIdleCallback(ScreenId screenId, uint64_t timestamp); 67 void DumpEventQueue(); 68 void ClearRedrawGPUCompositionCache(const std::set<int32_t>& bufferIds); 69 private: 70 RSHardwareThread() = default; 71 ~RSHardwareThread() = default; 72 RSHardwareThread(const RSHardwareThread&); 73 RSHardwareThread(const RSHardwareThread&&); 74 RSHardwareThread& operator=(const RSHardwareThread&); 75 RSHardwareThread& operator=(const RSHardwareThread&&); 76 77 void OnPrepareComplete(sptr<Surface>& surface, const PrepareCompleteParam& param, void* data); 78 void Redraw(const sptr<Surface>& surface, const std::vector<LayerInfoPtr>& layers, uint32_t screenId); 79 void RedrawScreenRCD(RSPaintFilterCanvas& canvas, const std::vector<LayerInfoPtr>& layers); 80 void PerformSetActiveMode(OutputPtr output, uint64_t timestamp, uint64_t constraintRelativeTime); 81 void ExecuteSwitchRefreshRate(uint32_t rate); 82 void AddRefreshRateCount(); 83 RefreshRateParam GetRefreshRateParam(); 84 bool IsDelayRequired(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, bool hasGameScene); 85 void CalculateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, uint32_t currentRate, 86 int64_t currTime); 87 std::shared_ptr<RSSurfaceOhos> CreateFrameBufferSurfaceOhos(const sptr<Surface>& surface); 88 #ifdef RES_SCHED_ENABLE 89 void SubScribeSystemAbility(); 90 sptr<VSyncSystemAbilityListener> saStatusChangeListener_ = nullptr; 91 #endif 92 #ifdef USE_VIDEO_PROCESSING_ENGINE 93 static GraphicColorGamut ComputeTargetColorGamut(const std::vector<LayerInfoPtr>& layers); 94 static GraphicPixelFormat ComputeTargetPixelFormat(const std::vector<LayerInfoPtr>& layers); 95 static bool ConvertColorGamutToSpaceType(const GraphicColorGamut& colorGamut, 96 HDI::Display::Graphic::Common::V1_0::CM_ColorSpaceType& colorSpaceInfo); 97 #endif 98 99 std::shared_ptr<AppExecFwk::EventRunner> runner_ = nullptr; 100 std::shared_ptr<AppExecFwk::EventHandler> handler_ = nullptr; 101 HdiBackend *hdiBackend_ = nullptr; 102 std::shared_ptr<RSBaseRenderEngine> uniRenderEngine_; 103 UniFallbackCallback redrawCb_; 104 std::mutex mutex_; 105 std::atomic<uint32_t> unExecuteTaskNum_ = 0; 106 int hardwareTid_ = -1; 107 std::shared_ptr<RSSurfaceOhos> frameBufferSurfaceOhos_; 108 109 HgmRefreshRates hgmRefreshRates_ = HgmRefreshRates::SET_RATE_NULL; 110 RSVBlankIdleCorrector vblankIdleCorrector_; 111 112 std::map<uint32_t, uint64_t> refreshRateCounts_; 113 sptr<SyncFence> releaseFence_ = SyncFence::InvalidFence(); 114 int64_t delayTime_ = 0; 115 int64_t lastCommitTime_ = 0; 116 117 friend class RSUniRenderThread; 118 friend class RSUifirstManager; 119 }; 120 } 121 122 namespace OHOS { 123 namespace AppExecFwk { 124 class RSHardwareDumper : public Dumper { 125 public: 126 virtual void Dump(const std::string& message) override; 127 virtual std::string GetTag() override; 128 void PrintDumpInfo(); 129 private: 130 std::string dumpInfo_; 131 }; 132 } // namespace AppExecFwk 133 } // namespace OHOS 134 #endif // RS_HARDWARE_THREAD_H 135