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#include "buffer_queue_consumer.h"
17
18namespace OHOS {
19BufferQueueConsumer::BufferQueueConsumer(sptr<BufferQueue>& bufferQueue)
20{
21    bufferQueue_ = bufferQueue;
22    if (bufferQueue_ != nullptr) {
23        bufferQueue_->GetName(name_);
24    }
25}
26
27BufferQueueConsumer::~BufferQueueConsumer()
28{
29}
30
31GSError BufferQueueConsumer::AcquireBuffer(sptr<SurfaceBuffer>& buffer, sptr<SyncFence>& fence,
32    int64_t &timestamp, std::vector<Rect> &damages)
33{
34    if (bufferQueue_ == nullptr) {
35        return SURFACE_ERROR_UNKOWN;
36    }
37    return bufferQueue_->AcquireBuffer(buffer, fence, timestamp, damages);
38}
39
40GSError BufferQueueConsumer::AcquireBuffer(IConsumerSurface::AcquireBufferReturnValue &returnValue,
41                                           int64_t expectPresentTimestamp, bool isUsingAutoTimestamp)
42{
43    if (bufferQueue_ == nullptr) {
44        return SURFACE_ERROR_UNKOWN;
45    }
46    return bufferQueue_->AcquireBuffer(returnValue, expectPresentTimestamp, isUsingAutoTimestamp);
47}
48
49GSError BufferQueueConsumer::ReleaseBuffer(sptr<SurfaceBuffer>& buffer, const sptr<SyncFence>& fence)
50{
51    if (bufferQueue_ == nullptr) {
52        return SURFACE_ERROR_UNKOWN;
53    }
54    return bufferQueue_->ReleaseBuffer(buffer, fence);
55}
56
57GSError BufferQueueConsumer::AttachBufferToQueue(sptr<SurfaceBuffer> buffer)
58{
59    if (bufferQueue_ == nullptr) {
60        return SURFACE_ERROR_UNKOWN;
61    }
62    return bufferQueue_->AttachBufferToQueue(buffer, InvokerType::CONSUMER_INVOKER);
63}
64
65GSError BufferQueueConsumer::DetachBufferFromQueue(sptr<SurfaceBuffer> buffer)
66{
67    if (bufferQueue_ == nullptr) {
68        return SURFACE_ERROR_UNKOWN;
69    }
70    return bufferQueue_->DetachBufferFromQueue(buffer, InvokerType::CONSUMER_INVOKER);
71}
72
73GSError BufferQueueConsumer::AttachBuffer(sptr<SurfaceBuffer>& buffer)
74{
75    return AttachBuffer(buffer, 0);
76}
77
78GSError BufferQueueConsumer::AttachBuffer(sptr<SurfaceBuffer>& buffer, int32_t timeOut)
79{
80    if (bufferQueue_ == nullptr) {
81        return GSERROR_INVALID_ARGUMENTS;
82    }
83    return bufferQueue_->AttachBuffer(buffer, timeOut);
84}
85
86GSError BufferQueueConsumer::DetachBuffer(sptr<SurfaceBuffer>& buffer)
87{
88    if (bufferQueue_ == nullptr) {
89        return GSERROR_INVALID_ARGUMENTS;
90    }
91    return bufferQueue_->DetachBuffer(buffer);
92}
93
94GSError BufferQueueConsumer::RegisterSurfaceDelegator(sptr<IRemoteObject> client, sptr<Surface> cSurface)
95{
96    if (bufferQueue_ == nullptr) {
97        return GSERROR_INVALID_ARGUMENTS;
98    }
99    return bufferQueue_->RegisterSurfaceDelegator(client, cSurface);
100}
101
102bool BufferQueueConsumer::QueryIfBufferAvailable()
103{
104    if (bufferQueue_ == nullptr) {
105        return false;
106    }
107    return bufferQueue_->QueryIfBufferAvailable();
108}
109
110GSError BufferQueueConsumer::RegisterConsumerListener(sptr<IBufferConsumerListener>& listener)
111{
112    if (bufferQueue_ == nullptr) {
113        return GSERROR_INVALID_ARGUMENTS;
114    }
115    return bufferQueue_->RegisterConsumerListener(listener);
116}
117
118GSError BufferQueueConsumer::RegisterConsumerListener(IBufferConsumerListenerClazz *listener)
119{
120    if (bufferQueue_ == nullptr) {
121        return GSERROR_INVALID_ARGUMENTS;
122    }
123    return bufferQueue_->RegisterConsumerListener(listener);
124}
125
126GSError BufferQueueConsumer::RegisterReleaseListener(OnReleaseFunc func)
127{
128    if (bufferQueue_ == nullptr) {
129        return GSERROR_INVALID_ARGUMENTS;
130    }
131    return bufferQueue_->RegisterReleaseListener(func);
132}
133
134GSError BufferQueueConsumer::RegisterDeleteBufferListener(OnDeleteBufferFunc func, bool isForUniRedraw)
135{
136    if (bufferQueue_ == nullptr) {
137        return GSERROR_INVALID_ARGUMENTS;
138    }
139    return bufferQueue_->RegisterDeleteBufferListener(func, isForUniRedraw);
140}
141
142GSError BufferQueueConsumer::UnregisterConsumerListener()
143{
144    if (bufferQueue_ == nullptr) {
145        return GSERROR_INVALID_ARGUMENTS;
146    }
147    return bufferQueue_->UnregisterConsumerListener();
148}
149
150GSError BufferQueueConsumer::SetDefaultWidthAndHeight(int32_t width, int32_t height)
151{
152    if (bufferQueue_ == nullptr) {
153        return GSERROR_INVALID_ARGUMENTS;
154    }
155    return bufferQueue_->SetDefaultWidthAndHeight(width, height);
156}
157
158GSError BufferQueueConsumer::SetDefaultUsage(uint64_t usage)
159{
160    if (bufferQueue_ == nullptr) {
161        return GSERROR_INVALID_ARGUMENTS;
162    }
163    return bufferQueue_->SetDefaultUsage(usage);
164}
165
166void BufferQueueConsumer::Dump(std::string &result) const
167{
168    if (bufferQueue_ == nullptr) {
169        return;
170    }
171    return bufferQueue_->Dump(result);
172}
173
174GraphicTransformType BufferQueueConsumer::GetTransform() const
175{
176    if (bufferQueue_ == nullptr) {
177        return GraphicTransformType::GRAPHIC_ROTATE_BUTT;
178    }
179    return bufferQueue_->GetTransform();
180}
181
182GSError BufferQueueConsumer::GetScalingMode(uint32_t sequence, ScalingMode &scalingMode) const
183{
184    if (bufferQueue_ == nullptr) {
185        return GSERROR_INVALID_ARGUMENTS;
186    }
187    return bufferQueue_->GetScalingMode(sequence, scalingMode);
188}
189
190GSError BufferQueueConsumer::QueryMetaDataType(uint32_t sequence, HDRMetaDataType &type) const
191{
192    if (bufferQueue_ == nullptr) {
193        return GSERROR_INVALID_ARGUMENTS;
194    }
195    return bufferQueue_->QueryMetaDataType(sequence, type);
196}
197
198GSError BufferQueueConsumer::GetMetaData(uint32_t sequence, std::vector<GraphicHDRMetaData> &metaData) const
199{
200    if (bufferQueue_ == nullptr) {
201        return GSERROR_INVALID_ARGUMENTS;
202    }
203    return bufferQueue_->GetMetaData(sequence, metaData);
204}
205
206GSError BufferQueueConsumer::GetMetaDataSet(uint32_t sequence, GraphicHDRMetadataKey &key,
207                                            std::vector<uint8_t> &metaData) const
208{
209    if (bufferQueue_ == nullptr) {
210        return GSERROR_INVALID_ARGUMENTS;
211    }
212    return bufferQueue_->GetMetaDataSet(sequence, key, metaData);
213}
214
215sptr<SurfaceTunnelHandle> BufferQueueConsumer::GetTunnelHandle() const
216{
217    if (bufferQueue_ == nullptr) {
218        return nullptr;
219    }
220    return bufferQueue_->GetTunnelHandle();
221}
222
223GSError BufferQueueConsumer::SetPresentTimestamp(uint32_t sequence, const GraphicPresentTimestamp &timestamp)
224{
225    if (bufferQueue_ == nullptr) {
226        return GSERROR_INVALID_ARGUMENTS;
227    }
228    return bufferQueue_->SetPresentTimestamp(sequence, timestamp);
229}
230
231bool BufferQueueConsumer::GetStatus() const
232{
233    if (bufferQueue_ == nullptr) {
234        return false;
235    }
236    return bufferQueue_->GetStatus();
237}
238
239void BufferQueueConsumer::SetStatus(bool status)
240{
241    if (bufferQueue_ == nullptr) {
242        return;
243    }
244    bufferQueue_->SetStatus(status);
245}
246
247void BufferQueueConsumer::SetBufferHold(bool hold)
248{
249    if (bufferQueue_ == nullptr) {
250        return;
251    }
252    bufferQueue_->SetBufferHold(hold);
253}
254
255GSError BufferQueueConsumer::OnConsumerDied()
256{
257    if (bufferQueue_ == nullptr) {
258        return GSERROR_INVALID_ARGUMENTS;
259    }
260    return bufferQueue_->OnConsumerDied();
261}
262
263GSError BufferQueueConsumer::GoBackground()
264{
265    if (bufferQueue_ == nullptr) {
266        return GSERROR_INVALID_ARGUMENTS;
267    }
268    return bufferQueue_->GoBackground();
269}
270
271float BufferQueueConsumer::GetHdrWhitePointBrightness() const
272{
273    if (bufferQueue_ == nullptr) {
274        return SURFACE_ERROR_UNKOWN;
275    }
276    return bufferQueue_->GetHdrWhitePointBrightness();
277}
278
279float BufferQueueConsumer::GetSdrWhitePointBrightness() const
280{
281    if (bufferQueue_ == nullptr) {
282        return SURFACE_ERROR_UNKOWN;
283    }
284    return bufferQueue_->GetSdrWhitePointBrightness();
285}
286
287GSError BufferQueueConsumer::IsSurfaceBufferInCache(uint32_t seqNum, bool &isInCache)
288{
289    if (bufferQueue_ == nullptr) {
290        return SURFACE_ERROR_UNKOWN;
291    }
292    return bufferQueue_->IsSurfaceBufferInCache(seqNum, isInCache);
293}
294
295GSError BufferQueueConsumer::GetGlobalAlpha(int32_t &alpha)
296{
297    if (bufferQueue_ == nullptr) {
298        return SURFACE_ERROR_UNKOWN;
299    }
300    return bufferQueue_->GetGlobalAlpha(alpha);
301}
302uint32_t BufferQueueConsumer::GetAvailableBufferCount() const
303{
304    if (bufferQueue_ == nullptr) {
305        return SURFACE_ERROR_UNKOWN;
306    }
307    return bufferQueue_->GetAvailableBufferCount();
308}
309} // namespace OHOS
310