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 <mutex> 20 21 #include "event_handler.h" 22 #include "hdi_backend.h" 23 #include "rs_main_thread.h" 24 25 namespace OHOS::Rosen { 26 using UniFallbackCallback = std::function<void(const sptr<Surface>& surface, const std::vector<LayerInfoPtr>& layers, 27 uint32_t screenId)>; 28 using OutputPtr = std::shared_ptr<HdiOutput>; 29 using LayerPtr = std::shared_ptr<HdiLayer>; 30 class ScheduledTask; 31 class RSHardwareThread { 32 public: 33 static RSHardwareThread& Instance(); 34 void Start(); 35 void PostTask(const std::function<void()>& task); 36 void CommitAndReleaseLayers(OutputPtr output, const std::vector<LayerInfoPtr>& layers); 37 void ReleaseBuffer(sptr<SurfaceBuffer> buffer, sptr<SyncFence> releaseFence, sptr<IConsumerSurface> cSurface); 38 template<typename Task, typename Return = std::invoke_result_t<Task>> ScheduleTask(Task && task)39 std::future<Return> ScheduleTask(Task&& task) 40 { 41 auto [scheduledTask, taskFuture] = Detail::ScheduledTask<Task>::Create(std::forward<Task&&>(task)); 42 PostTask([t(std::move(scheduledTask))]() { t->Run(); }); 43 return std::move(taskFuture); 44 } 45 private: 46 RSHardwareThread() = default; 47 ~RSHardwareThread() = default; 48 RSHardwareThread(const RSHardwareThread&); 49 RSHardwareThread(const RSHardwareThread&&); 50 RSHardwareThread& operator=(const RSHardwareThread&); 51 RSHardwareThread& operator=(const RSHardwareThread&&); 52 53 void OnPrepareComplete(sptr<Surface>& surface, const PrepareCompleteParam& param, void* data); 54 void Redraw(const sptr<Surface>& surface, const std::vector<LayerInfoPtr>& layers, uint32_t screenId); 55 void ReleaseLayers(OutputPtr output, const std::unordered_map<uint32_t, LayerPtr>& layerMap); 56 void LayerPresentTimestamp(const LayerInfoPtr& layer, const sptr<IConsumerSurface>& surface) const; 57 void PerformSetActiveMode(); 58 59 std::shared_ptr<AppExecFwk::EventRunner> runner_ = nullptr; 60 std::shared_ptr<AppExecFwk::EventHandler> handler_ = nullptr; 61 HdiBackend *hdiBackend_ = nullptr; 62 std::shared_ptr<RSBaseRenderEngine> uniRenderEngine_; 63 UniFallbackCallback redrawCb_; 64 std::mutex mutex_; 65 66 bool lockRefreshRateOnce_ = false; 67 HgmRefreshRates hgmRefreshRates_; 68 HgmRefreshRateModes hgmRefreshRateModes_; 69 }; 70 } 71 #endif // RS_HARDWARE_THREAD_H 72