1 /*
2  * Copyright (c) 2021 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 FRAMEWORKS_SURFACE_INCLUDE_CONSUMER_SURFACE_H
17 #define FRAMEWORKS_SURFACE_INCLUDE_CONSUMER_SURFACE_H
18 
19 #include <map>
20 #include <string>
21 
22 #include <iconsumer_surface.h>
23 
24 #include "buffer_queue.h"
25 #include "buffer_queue_producer.h"
26 #include "buffer_queue_consumer.h"
27 
28 namespace OHOS {
29 class ConsumerSurface : public IConsumerSurface {
30 public:
31     ConsumerSurface(const std::string &name, bool isShared = false);
32     virtual ~ConsumerSurface();
33     GSError Init();
34 
35     bool IsConsumer() const override;
36     sptr<IBufferProducer> GetProducer() const override;
37 
38     GSError GetProducerInitInfo(ProducerInitInfo &info) override;
39 
40     SURFACE_HIDDEN GSError RequestBuffer(sptr<SurfaceBuffer>& buffer,
41         int32_t &fence, BufferRequestConfig &config) override
42     {
43         return GSERROR_NOT_SUPPORT;
44     }
45 
46     SURFACE_HIDDEN GSError RequestBuffers(std::vector<sptr<SurfaceBuffer>> &buffers,
47         std::vector<sptr<SyncFence>> &fences, BufferRequestConfig &config) override
48     {
49         return GSERROR_NOT_SUPPORT;
50     }
51 
52     SURFACE_HIDDEN GSError CancelBuffer(sptr<SurfaceBuffer>& buffer) override
53     {
54         return GSERROR_NOT_SUPPORT;
55     }
56 
57     SURFACE_HIDDEN GSError FlushBuffer(sptr<SurfaceBuffer>& buffer, int32_t fence, BufferFlushConfig &config) override
58     {
59         return GSERROR_NOT_SUPPORT;
60     }
61 
62     GSError AcquireBuffer(sptr<SurfaceBuffer>& buffer, int32_t &fence,
63                           int64_t &timestamp, Rect &damage) override;
64 
65     GSError ReleaseBuffer(sptr<SurfaceBuffer>& buffer, int32_t fence) override;
66 
67     SURFACE_HIDDEN GSError RequestBuffer(sptr<SurfaceBuffer>& buffer,
68         sptr<SyncFence>& fence, BufferRequestConfig &config) override
69     {
70         return GSERROR_NOT_SUPPORT;
71     }
72 
73     SURFACE_HIDDEN GSError FlushBuffer(sptr<SurfaceBuffer>& buffer,
74         const sptr<SyncFence>& fence, BufferFlushConfig &config) override
75     {
76         return GSERROR_NOT_SUPPORT;
77     }
78 
79     SURFACE_HIDDEN GSError FlushBuffer(sptr<SurfaceBuffer>& buffer, const sptr<SyncFence>& fence,
80         BufferFlushConfigWithDamages &config) override
81     {
82         return GSERROR_NOT_SUPPORT;
83     }
84 
85     SURFACE_HIDDEN GSError FlushBuffers(const std::vector<sptr<SurfaceBuffer>> &buffers,
86         const std::vector<sptr<SyncFence>> &fences, const std::vector<BufferFlushConfigWithDamages> &config) override
87     {
88         return GSERROR_NOT_SUPPORT;
89     }
90 
91     SURFACE_HIDDEN GSError GetLastFlushedBuffer(sptr<SurfaceBuffer>& buffer,
92         sptr<SyncFence>& fence, float matrix[16], bool isUseNewMatrix = false) override
93     {
94         return GSERROR_NOT_SUPPORT;
95     }
96 
97     GSError AcquireBuffer(sptr<SurfaceBuffer>& buffer, sptr<SyncFence>& fence,
98                           int64_t &timestamp, Rect &damage) override;
99     GSError AcquireBuffer(sptr<SurfaceBuffer>& buffer, sptr<SyncFence>& fence,
100                           int64_t &timestamp, std::vector<Rect> &damages) override;
101     GSError AcquireBuffer(AcquireBufferReturnValue &returnValue, int64_t expectPresentTimestamp,
102                           bool isUsingAutoTimestamp) override;
103     GSError ReleaseBuffer(sptr<SurfaceBuffer>& buffer, const sptr<SyncFence>& fence) override;
104 
105     GSError AttachBuffer(sptr<SurfaceBuffer>& buffer) override;
106     GSError DetachBuffer(sptr<SurfaceBuffer>& buffer) override;
107 
108     bool QueryIfBufferAvailable() override;
109 
110     uint32_t GetQueueSize() override;
111     GSError SetQueueSize(uint32_t queueSize) override;
112 
113     const std::string& GetName() override;
114 
115     GSError SetDefaultWidthAndHeight(int32_t width, int32_t height) override;
116     int32_t GetDefaultWidth() override;
117     int32_t GetDefaultHeight() override;
118     GSError SetDefaultUsage(uint64_t usage) override;
119     uint64_t GetDefaultUsage() override;
120 
121     GSError SetUserData(const std::string &key, const std::string &val) override;
122     std::string GetUserData(const std::string &key) override;
123 
124     GSError RegisterConsumerListener(sptr<IBufferConsumerListener>& listener) override;
125     GSError RegisterConsumerListener(IBufferConsumerListenerClazz *listener) override;
126     GSError RegisterReleaseListener(OnReleaseFunc func) override;
127     SURFACE_HIDDEN GSError UnRegisterReleaseListener() override
128     {
129         return GSERROR_OK;
130     }
131     GSError RegisterDeleteBufferListener(OnDeleteBufferFunc func, bool isForUniRedraw = false) override;
132     GSError UnregisterConsumerListener() override;
133 
134     uint64_t GetUniqueId() const override;
135 
136     void Dump(std::string &result) const override;
137 
138     SURFACE_HIDDEN GSError CleanCache(bool cleanAll = false) override
139     {
140         return GSERROR_NOT_SUPPORT;
141     }
142 
143     GSError GoBackground() override;
144 
145     GSError SetTransform(GraphicTransformType transform) override;
146     GraphicTransformType GetTransform() const override;
147 
148     SURFACE_HIDDEN GSError IsSupportedAlloc(const std::vector<BufferVerifyAllocInfo> &infos,
149         std::vector<bool> &supporteds) override
150     {
151         return GSERROR_NOT_SUPPORT;
152     }
153 
154     SURFACE_HIDDEN GSError Connect() override
155     {
156         return GSERROR_NOT_SUPPORT;
157     }
158 
159     SURFACE_HIDDEN GSError Disconnect() override
160     {
161         return GSERROR_NOT_SUPPORT;
162     }
163     GSError SetScalingMode(uint32_t sequence, ScalingMode scalingMode) override;
164     GSError GetScalingMode(uint32_t sequence, ScalingMode &scalingMode) override;
165     GSError SetMetaData(uint32_t sequence, const std::vector<GraphicHDRMetaData> &metaData) override;
166     GSError SetMetaDataSet(uint32_t sequence, GraphicHDRMetadataKey key, const std::vector<uint8_t> &metaData) override;
167     GSError QueryMetaDataType(uint32_t sequence, HDRMetaDataType &type) const override;
168     GSError GetMetaData(uint32_t sequence, std::vector<GraphicHDRMetaData> &metaData) const override;
169     GSError GetMetaDataSet(uint32_t sequence, GraphicHDRMetadataKey &key,
170                            std::vector<uint8_t> &metaData) const override;
171     GSError SetTunnelHandle(const GraphicExtDataHandle *handle) override;
172     sptr<SurfaceTunnelHandle> GetTunnelHandle() const override;
173     GSError SetPresentTimestamp(uint32_t sequence, const GraphicPresentTimestamp &timestamp) override;
174     SURFACE_HIDDEN GSError GetPresentTimestamp(uint32_t sequence,
175         GraphicPresentTimestampType type, int64_t &time) const override
176     {
177         return GSERROR_NOT_SUPPORT;
178     }
179 
180     SURFACE_HIDDEN int32_t GetDefaultFormat() override
181     {
182         return 0;
183     }
184     SURFACE_HIDDEN GSError SetDefaultFormat(int32_t format) override
185     {
186         return GSERROR_NOT_SUPPORT;
187     }
188     SURFACE_HIDDEN int32_t GetDefaultColorGamut() override
189     {
190         return 0;
191     }
192     SURFACE_HIDDEN GSError SetDefaultColorGamut(int32_t colorGamut) override
193     {
194         return GSERROR_NOT_SUPPORT;
195     }
196 
197     SURFACE_HIDDEN sptr<NativeSurface> GetNativeSurface() override
198     {
199         return nullptr;
200     }
201     SURFACE_HIDDEN GSError SetWptrNativeWindowToPSurface(void* nativeWindow) override
202     {
203         return GSERROR_NOT_SUPPORT;
204     }
205     GSError AttachBuffer(sptr<SurfaceBuffer>& buffer, int32_t timeOut) override;
206     GSError RegisterSurfaceDelegator(sptr<IRemoteObject> client) override;
207     SURFACE_HIDDEN GSError RegisterReleaseListener(OnReleaseFuncWithFence func) override
208     {
209         return GSERROR_NOT_SUPPORT;
210     }
211     GSError RegisterUserDataChangeListener(const std::string &funcName, OnUserDataChangeFunc func) override;
212     GSError UnRegisterUserDataChangeListener(const std::string &funcName) override;
213     GSError ClearUserDataChangeListener() override;
214     void ConsumerRequestCpuAccess(bool on) override;
215     GSError AttachBufferToQueue(sptr<SurfaceBuffer> buffer) override;
216     GSError DetachBufferFromQueue(sptr<SurfaceBuffer> buffer) override;
217     GraphicTransformType GetTransformHint() const override;
218     GSError SetTransformHint(GraphicTransformType transformHint) override;
219     inline bool IsBufferHold() override
220     {
221         if (consumer_ == nullptr) {
222             return false;
223         }
224         return consumer_->IsBufferHold();
225     }
226     void SetBufferHold(bool hold) override;
227 
228     void SetRequestWidthAndHeight(int32_t width, int32_t height) override;
229     int32_t GetRequestWidth() override;
230     int32_t GetRequestHeight() override;
231     GSError SetScalingMode(ScalingMode scalingMode) override;
232     GSError SetSurfaceSourceType(OHSurfaceSource sourceType) override;
233     OHSurfaceSource GetSurfaceSourceType() const override;
234     GSError SetSurfaceAppFrameworkType(std::string appFrameworkType) override;
235     std::string GetSurfaceAppFrameworkType() const override;
236 
237     GSError SetHdrWhitePointBrightness(float brightness) override;
238     GSError SetSdrWhitePointBrightness(float brightness) override;
239     float GetHdrWhitePointBrightness() const override;
240     float GetSdrWhitePointBrightness() const override;
241 
242     GSError GetSurfaceBufferTransformType(sptr<SurfaceBuffer> buffer, GraphicTransformType *transformType) override;
243     GSError IsSurfaceBufferInCache(uint32_t seqNum, bool &isInCache) override;
244     GSError AcquireLastFlushedBuffer(sptr<SurfaceBuffer> &buffer, sptr<SyncFence> &fence,
245         float matrix[16], uint32_t matrixSize, bool isUseNewMatrix) override;
246     GSError ReleaseLastFlushedBuffer(sptr<SurfaceBuffer> buffer) override;
247     GSError SetGlobalAlpha(int32_t alpha) override;
248     GSError GetGlobalAlpha(int32_t &alpha) override;
249     uint32_t GetAvailableBufferCount() const override;
250 private:
251     std::map<std::string, std::string> userData_;
252     sptr<BufferQueueProducer> producer_ = nullptr;
253     sptr<BufferQueueConsumer> consumer_ = nullptr;
254     std::string name_ = "not init";
255     bool isShared_ = false;
256     std::map<std::string, OnUserDataChangeFunc> onUserDataChange_;
257     std::mutex lockMutex_;
258     uint64_t uniqueId_ = 0;
259 };
260 } // namespace OHOS
261 
262 #endif // FRAMEWORKS_SURFACE_INCLUDE_CONSUMER_SURFACE_H
263