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 "rs_main_thread.h" 25 26 namespace OHOS::Rosen { 27 using UniFallbackCallback = std::function<void(const sptr<Surface>& surface, const std::vector<LayerInfoPtr>& layers, 28 uint32_t screenId)>; 29 using OutputPtr = std::shared_ptr<HdiOutput>; 30 using LayerPtr = std::shared_ptr<HdiLayer>; 31 class ScheduledTask; 32 class RSHardwareThread { 33 public: 34 static RSHardwareThread& Instance(); 35 void Start(); 36 void PostTask(const std::function<void()>& task); 37 void PostDelayTask(const std::function<void()>& task, int64_t delayTime); 38 void CommitAndReleaseLayers(OutputPtr output, const std::vector<LayerInfoPtr>& layers); 39 void ReleaseBuffer(sptr<SurfaceBuffer> buffer, sptr<SyncFence> releaseFence, sptr<IConsumerSurface> cSurface); 40 template<typename Task, typename Return = std::invoke_result_t<Task>> ScheduleTask(Task && task)41 std::future<Return> ScheduleTask(Task&& task) 42 { 43 auto [scheduledTask, taskFuture] = Detail::ScheduledTask<Task>::Create(std::forward<Task&&>(task)); 44 PostTask([t(std::move(scheduledTask))]() { t->Run(); }); 45 return std::move(taskFuture); 46 } 47 uint32_t GetunExcuteTaskNum(); 48 void RefreshRateCounts(std::string& dumpString); 49 void ClearRefreshRateCounts(std::string& dumpString); 50 int GetHardwareTid() const; 51 GSError ClearFrameBuffers(OutputPtr output); 52 private: 53 RSHardwareThread() = default; 54 ~RSHardwareThread() = default; 55 RSHardwareThread(const RSHardwareThread&); 56 RSHardwareThread(const RSHardwareThread&&); 57 RSHardwareThread& operator=(const RSHardwareThread&); 58 RSHardwareThread& operator=(const RSHardwareThread&&); 59 60 void OnPrepareComplete(sptr<Surface>& surface, const PrepareCompleteParam& param, void* data); 61 void Redraw(const sptr<Surface>& surface, const std::vector<LayerInfoPtr>& layers, uint32_t screenId); 62 void ReleaseLayers(OutputPtr output, const std::unordered_map<uint32_t, LayerPtr>& layerMap); 63 void LayerPresentTimestamp(const LayerInfoPtr& layer, const sptr<IConsumerSurface>& surface) const; 64 void PerformSetActiveMode(OutputPtr output, uint64_t timestamp); 65 void ExecuteSwitchRefreshRate(uint32_t rate); 66 void AddRefreshRateCount(); 67 #ifdef USE_VIDEO_PROCESSING_ENGINE 68 static GraphicColorGamut ComputeTargetColorGamut(const std::vector<LayerInfoPtr>& layers); 69 static GraphicPixelFormat ComputeTargetPixelFormat(const std::vector<LayerInfoPtr>& layers); 70 #endif 71 72 std::shared_ptr<AppExecFwk::EventRunner> runner_ = nullptr; 73 std::shared_ptr<AppExecFwk::EventHandler> handler_ = nullptr; 74 HdiBackend *hdiBackend_ = nullptr; 75 std::shared_ptr<RSBaseRenderEngine> uniRenderEngine_; 76 UniFallbackCallback redrawCb_; 77 std::mutex mutex_; 78 std::atomic<uint32_t> unExcuteTaskNum_ = 0; 79 int hardwareTid_ = -1; 80 81 HgmRefreshRates hgmRefreshRates_; 82 83 std::map<uint32_t, uint64_t> refreshRateCounts_; 84 }; 85 } 86 #endif // RS_HARDWARE_THREAD_H 87