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 "consumer_surface.h"
17
18#include <cinttypes>
19
20#include "buffer_log.h"
21#include "buffer_queue_producer.h"
22#include "sync_fence.h"
23
24namespace OHOS {
25sptr<Surface> Surface::CreateSurfaceAsConsumer(std::string name, bool isShared)
26{
27    sptr<ConsumerSurface> surf = new ConsumerSurface(name, isShared);
28    if (surf->Init() != GSERROR_OK) {
29        BLOGE("consumer surf init failed");
30        return nullptr;
31    }
32    return surf;
33}
34
35sptr<IConsumerSurface> IConsumerSurface::Create(std::string name, bool isShared)
36{
37    sptr<ConsumerSurface> surf = new ConsumerSurface(name, isShared);
38    if (surf->Init() != GSERROR_OK) {
39        BLOGE("consumer surf init failed");
40        return nullptr;
41    }
42    return surf;
43}
44
45ConsumerSurface::ConsumerSurface(const std::string& name, bool isShared)
46    : name_(name), isShared_(isShared)
47{
48    consumer_ = nullptr;
49    producer_ = nullptr;
50}
51
52ConsumerSurface::~ConsumerSurface()
53{
54    if (consumer_ != nullptr) {
55        consumer_->OnConsumerDied();
56        consumer_->SetStatus(false);
57    }
58    if (producer_ != nullptr) {
59        BLOGI("~ConsumerSurface, producer_ sptrCnt: %{public}d, uniqueId: %{public}" PRIu64 ".",
60            producer_->GetSptrRefCount(), uniqueId_);
61    }
62    consumer_ = nullptr;
63    producer_ = nullptr;
64}
65
66GSError ConsumerSurface::Init()
67{
68    sptr<BufferQueue> queue_ = new BufferQueue(name_, isShared_);
69    producer_ = new BufferQueueProducer(queue_);
70    consumer_ = new BufferQueueConsumer(queue_);
71    uniqueId_ = GetUniqueId();
72    BLOGD("ConsumerSurface Init, uniqueId: %{public}" PRIu64 ".", uniqueId_);
73    return GSERROR_OK;
74}
75
76bool ConsumerSurface::IsConsumer() const
77{
78    return true;
79}
80
81sptr<IBufferProducer> ConsumerSurface::GetProducer() const
82{
83    return producer_;
84}
85
86GSError ConsumerSurface::GetProducerInitInfo(ProducerInitInfo& info)
87{
88    return GSERROR_NOT_SUPPORT;
89}
90
91GSError ConsumerSurface::AcquireBuffer(sptr<SurfaceBuffer>& buffer, sptr<SyncFence>& fence,
92                                       int64_t& timestamp, Rect& damage)
93{
94    std::vector<Rect> damages;
95    GSError ret = AcquireBuffer(buffer, fence, timestamp, damages);
96    if (ret != GSERROR_OK) {
97        return ret;
98    }
99    if (damages.size() == 1) {
100        damage = damages[0];
101        return GSERROR_OK;
102    }
103    BLOGE("damages is %{public}zu, uniqueId: %{public}" PRIu64 ".", damages.size(), uniqueId_);
104    return GSERROR_INVALID_ARGUMENTS;
105}
106
107GSError ConsumerSurface::AcquireBuffer(sptr<SurfaceBuffer>& buffer, sptr<SyncFence>& fence,
108                                       int64_t& timestamp, std::vector<Rect>& damages)
109{
110    if (consumer_ == nullptr) {
111        return GSERROR_INVALID_ARGUMENTS;
112    }
113    return consumer_->AcquireBuffer(buffer, fence, timestamp, damages);
114}
115
116GSError ConsumerSurface::AcquireBuffer(AcquireBufferReturnValue &returnValue, int64_t expectPresentTimestamp,
117                                       bool isUsingAutoTimestamp)
118{
119    if (consumer_ == nullptr) {
120        return GSERROR_INVALID_ARGUMENTS;
121    }
122    return consumer_->AcquireBuffer(returnValue, expectPresentTimestamp, isUsingAutoTimestamp);
123}
124
125GSError ConsumerSurface::ReleaseBuffer(sptr<SurfaceBuffer>& buffer, const sptr<SyncFence>& fence)
126{
127    if (buffer == nullptr || consumer_ == nullptr) {
128        return GSERROR_INVALID_ARGUMENTS;
129    }
130    return consumer_->ReleaseBuffer(buffer, fence);
131}
132
133GSError ConsumerSurface::AcquireBuffer(sptr<SurfaceBuffer>& buffer, int32_t& fence,
134                                       int64_t& timestamp, Rect& damage)
135{
136    sptr<SyncFence> syncFence = SyncFence::InvalidFence();
137    auto ret = AcquireBuffer(buffer, syncFence, timestamp, damage);
138    if (ret != GSERROR_OK) {
139        fence = -1;
140        return ret;
141    }
142    fence = syncFence->Dup();
143    return GSERROR_OK;
144}
145
146GSError ConsumerSurface::ReleaseBuffer(sptr<SurfaceBuffer>& buffer, int32_t fence)
147{
148    sptr<SyncFence> syncFence = new SyncFence(fence);
149    return ReleaseBuffer(buffer, syncFence);
150}
151
152GSError ConsumerSurface::AttachBufferToQueue(sptr<SurfaceBuffer> buffer)
153{
154    if (buffer == nullptr || consumer_ == nullptr) {
155        return GSERROR_INVALID_ARGUMENTS;
156    }
157    buffer->SetConsumerAttachBufferFlag(true);
158    return consumer_->AttachBufferToQueue(buffer);
159}
160
161GSError ConsumerSurface::DetachBufferFromQueue(sptr<SurfaceBuffer> buffer)
162{
163    if (buffer == nullptr || consumer_ == nullptr) {
164        return GSERROR_INVALID_ARGUMENTS;
165    }
166    buffer->SetConsumerAttachBufferFlag(false);
167    return consumer_->DetachBufferFromQueue(buffer);
168}
169
170GSError ConsumerSurface::AttachBuffer(sptr<SurfaceBuffer>& buffer)
171{
172    if (buffer == nullptr || consumer_ == nullptr) {
173        return GSERROR_INVALID_ARGUMENTS;
174    }
175    return consumer_->AttachBuffer(buffer);
176}
177
178GSError ConsumerSurface::AttachBuffer(sptr<SurfaceBuffer>& buffer, int32_t timeOut)
179{
180    if (buffer == nullptr || consumer_ == nullptr) {
181        return GSERROR_INVALID_ARGUMENTS;
182    }
183    return consumer_->AttachBuffer(buffer, timeOut);
184}
185
186GSError ConsumerSurface::DetachBuffer(sptr<SurfaceBuffer>& buffer)
187{
188    if (buffer == nullptr || consumer_ == nullptr) {
189        return GSERROR_INVALID_ARGUMENTS;
190    }
191    return consumer_->DetachBuffer(buffer);
192}
193
194GSError ConsumerSurface::RegisterSurfaceDelegator(sptr<IRemoteObject> client)
195{
196    if (client == nullptr || consumer_ == nullptr) {
197        return GSERROR_INVALID_ARGUMENTS;
198    }
199    return consumer_->RegisterSurfaceDelegator(client, this);
200}
201
202bool ConsumerSurface::QueryIfBufferAvailable()
203{
204    if (consumer_ == nullptr) {
205        return false;
206    }
207    return consumer_->QueryIfBufferAvailable();
208}
209
210uint32_t ConsumerSurface::GetQueueSize()
211{
212    if (producer_ == nullptr) {
213        return 0;
214    }
215    return producer_->GetQueueSize();
216}
217
218GSError ConsumerSurface::SetQueueSize(uint32_t queueSize)
219{
220    if (producer_ == nullptr) {
221        return GSERROR_INVALID_ARGUMENTS;
222    }
223    return producer_->SetQueueSize(queueSize);
224}
225
226const std::string& ConsumerSurface::GetName()
227{
228    return name_;
229}
230
231GSError ConsumerSurface::SetDefaultWidthAndHeight(int32_t width, int32_t height)
232{
233    if (consumer_ == nullptr) {
234        return GSERROR_INVALID_ARGUMENTS;
235    }
236    return consumer_->SetDefaultWidthAndHeight(width, height);
237}
238
239int32_t ConsumerSurface::GetDefaultWidth()
240{
241    if (producer_ == nullptr) {
242        return -1;
243    }
244    return producer_->GetDefaultWidth();
245}
246
247int32_t ConsumerSurface::GetDefaultHeight()
248{
249    if (producer_ == nullptr) {
250        return -1;
251    }
252    return producer_->GetDefaultHeight();
253}
254
255GSError ConsumerSurface::SetDefaultUsage(uint64_t usage)
256{
257    if (consumer_ == nullptr) {
258        return GSERROR_INVALID_ARGUMENTS;
259    }
260    return consumer_->SetDefaultUsage(usage);
261}
262
263uint64_t ConsumerSurface::GetDefaultUsage()
264{
265    if (producer_ == nullptr) {
266        return 0;
267    }
268    return producer_->GetDefaultUsage();
269}
270
271GSError ConsumerSurface::SetUserData(const std::string& key, const std::string& val)
272{
273    std::lock_guard<std::mutex> lockGuard(lockMutex_);
274    if (userData_.size() >= SURFACE_MAX_USER_DATA_COUNT) {
275        BLOGE("userData_ size(%{public}zu) out, uniqueId: %{public}" PRIu64 ".", userData_.size(), uniqueId_);
276        return GSERROR_OUT_OF_RANGE;
277    }
278
279    auto iterUserData = userData_.find(key);
280    if (iterUserData != userData_.end() && iterUserData->second == val) {
281        BLOGE("not find key:%{public}s, val:%{public}s exist, uniqueId: %{public}" PRIu64 ".",
282            key.c_str(), val.c_str(), uniqueId_);
283        return GSERROR_API_FAILED;
284    }
285
286    userData_[key] = val;
287    auto iter = onUserDataChange_.begin();
288    while (iter != onUserDataChange_.end()) {
289        if (iter->second != nullptr) {
290            iter->second(key, val);
291        }
292        iter++;
293    }
294
295    return GSERROR_OK;
296}
297
298std::string ConsumerSurface::GetUserData(const std::string& key)
299{
300    std::lock_guard<std::mutex> lockGuard(lockMutex_);
301    if (userData_.find(key) != userData_.end()) {
302        return userData_[key];
303    }
304
305    return "";
306}
307
308GSError ConsumerSurface::RegisterConsumerListener(sptr<IBufferConsumerListener>& listener)
309{
310    if (listener == nullptr || consumer_ == nullptr) {
311        return GSERROR_INVALID_ARGUMENTS;
312    }
313    return consumer_->RegisterConsumerListener(listener);
314}
315
316GSError ConsumerSurface::RegisterConsumerListener(IBufferConsumerListenerClazz *listener)
317{
318    if (listener == nullptr || consumer_ == nullptr) {
319        return GSERROR_INVALID_ARGUMENTS;
320    }
321    return consumer_->RegisterConsumerListener(listener);
322}
323
324GSError ConsumerSurface::RegisterReleaseListener(OnReleaseFunc func)
325{
326    if (func == nullptr || consumer_ == nullptr) {
327        return GSERROR_INVALID_ARGUMENTS;
328    }
329    return consumer_->RegisterReleaseListener(func);
330}
331
332GSError ConsumerSurface::RegisterDeleteBufferListener(OnDeleteBufferFunc func, bool isForUniRedraw)
333{
334    if (func == nullptr || consumer_ == nullptr) {
335        return GSERROR_INVALID_ARGUMENTS;
336    }
337    return consumer_->RegisterDeleteBufferListener(func, isForUniRedraw);
338}
339
340GSError ConsumerSurface::UnregisterConsumerListener()
341{
342    if (consumer_ == nullptr) {
343        return GSERROR_INVALID_ARGUMENTS;
344    }
345    return consumer_->UnregisterConsumerListener();
346}
347
348GSError ConsumerSurface::RegisterUserDataChangeListener(const std::string& funcName, OnUserDataChangeFunc func)
349{
350    if (func == nullptr) {
351        return GSERROR_INVALID_ARGUMENTS;
352    }
353    std::lock_guard<std::mutex> lockGuard(lockMutex_);
354    if (onUserDataChange_.find(funcName) != onUserDataChange_.end()) {
355        BLOGD("already register func: %{public}s, uniqueId: %{public}" PRIu64 ".",
356            funcName.c_str(), uniqueId_);
357        return GSERROR_INVALID_ARGUMENTS;
358    }
359
360    onUserDataChange_[funcName] = func;
361    return GSERROR_OK;
362}
363
364GSError ConsumerSurface::UnRegisterUserDataChangeListener(const std::string& funcName)
365{
366    std::lock_guard<std::mutex> lockGuard(lockMutex_);
367    if (onUserDataChange_.erase(funcName) == 0) {
368        BLOGD("no register funcName: %{public}s, uniqueId: %{public}" PRIu64 ".",
369            funcName.c_str(), uniqueId_);
370        return GSERROR_INVALID_ARGUMENTS;
371    }
372
373    return GSERROR_OK;
374}
375
376GSError ConsumerSurface::ClearUserDataChangeListener()
377{
378    std::lock_guard<std::mutex> lockGuard(lockMutex_);
379    onUserDataChange_.clear();
380    return GSERROR_OK;
381}
382
383GSError ConsumerSurface::GoBackground()
384{
385    if (consumer_ == nullptr) {
386        return GSERROR_INVALID_ARGUMENTS;
387    }
388    if (producer_ != nullptr) {
389        BLOGD("GoBackground, uniqueId: %{public}" PRIu64 ".", uniqueId_);
390    }
391    return consumer_->GoBackground();
392}
393
394uint64_t ConsumerSurface::GetUniqueId() const
395{
396    if (producer_ == nullptr) {
397        return 0;
398    }
399    return producer_->GetUniqueId();
400}
401
402void ConsumerSurface::Dump(std::string& result) const
403{
404    if (consumer_ == nullptr) {
405        return;
406    }
407    return consumer_->Dump(result);
408}
409
410GSError ConsumerSurface::SetTransform(GraphicTransformType transform)
411{
412    if (producer_ == nullptr) {
413        return GSERROR_INVALID_ARGUMENTS;
414    }
415    return producer_->SetTransform(transform);
416}
417
418GraphicTransformType ConsumerSurface::GetTransform() const
419{
420    if (consumer_ == nullptr) {
421        return GraphicTransformType::GRAPHIC_ROTATE_BUTT;
422    }
423    return consumer_->GetTransform();
424}
425
426GSError ConsumerSurface::SetScalingMode(uint32_t sequence, ScalingMode scalingMode)
427{
428    if (producer_ == nullptr || scalingMode < ScalingMode::SCALING_MODE_FREEZE ||
429        scalingMode > ScalingMode::SCALING_MODE_SCALE_FIT) {
430        return GSERROR_INVALID_ARGUMENTS;
431    }
432    return producer_->SetScalingMode(sequence, scalingMode);
433}
434
435GSError ConsumerSurface::SetScalingMode(ScalingMode scalingMode)
436{
437    if (producer_ == nullptr || scalingMode < ScalingMode::SCALING_MODE_FREEZE ||
438        scalingMode > ScalingMode::SCALING_MODE_SCALE_FIT) {
439        return GSERROR_INVALID_ARGUMENTS;
440    }
441    return producer_->SetScalingMode(scalingMode);
442}
443
444GSError ConsumerSurface::GetScalingMode(uint32_t sequence, ScalingMode& scalingMode)
445{
446    if (consumer_ == nullptr) {
447        return GSERROR_INVALID_ARGUMENTS;
448    }
449    return consumer_->GetScalingMode(sequence, scalingMode);
450}
451
452GSError ConsumerSurface::SetMetaData(uint32_t sequence, const std::vector<GraphicHDRMetaData>& metaData)
453{
454    if (producer_ == nullptr || metaData.size() == 0) {
455        return GSERROR_INVALID_ARGUMENTS;
456    }
457    return producer_->SetMetaData(sequence, metaData);
458}
459
460GSError ConsumerSurface::SetMetaDataSet(uint32_t sequence, GraphicHDRMetadataKey key,
461                                        const std::vector<uint8_t>& metaData)
462{
463    if (producer_ == nullptr || key < GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X ||
464        key > GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR_VIVID || metaData.size() == 0) {
465        return GSERROR_INVALID_ARGUMENTS;
466    }
467    return producer_->SetMetaDataSet(sequence, key, metaData);
468}
469
470GSError ConsumerSurface::QueryMetaDataType(uint32_t sequence, HDRMetaDataType& type) const
471{
472    if (consumer_ == nullptr) {
473        return GSERROR_INVALID_ARGUMENTS;
474    }
475    return consumer_->QueryMetaDataType(sequence, type);
476}
477
478GSError ConsumerSurface::GetMetaData(uint32_t sequence, std::vector<GraphicHDRMetaData>& metaData) const
479{
480    if (consumer_ == nullptr) {
481        return GSERROR_INVALID_ARGUMENTS;
482    }
483    return consumer_->GetMetaData(sequence, metaData);
484}
485
486GSError ConsumerSurface::GetMetaDataSet(uint32_t sequence, GraphicHDRMetadataKey& key,
487                                        std::vector<uint8_t>& metaData) const
488{
489    if (consumer_ == nullptr) {
490        return GSERROR_INVALID_ARGUMENTS;
491    }
492    return consumer_->GetMetaDataSet(sequence, key, metaData);
493}
494
495GSError ConsumerSurface::SetTunnelHandle(const GraphicExtDataHandle *handle)
496{
497    if (producer_ == nullptr || handle == nullptr || handle->reserveInts == 0) {
498        return GSERROR_INVALID_ARGUMENTS;
499    }
500    return producer_->SetTunnelHandle(handle);
501}
502
503sptr<SurfaceTunnelHandle> ConsumerSurface::GetTunnelHandle() const
504{
505    if (consumer_ == nullptr) {
506        return nullptr;
507    }
508    return consumer_->GetTunnelHandle();
509}
510
511void ConsumerSurface::SetBufferHold(bool hold)
512{
513    if (consumer_ == nullptr) {
514        return;
515    }
516    consumer_->SetBufferHold(hold);
517}
518
519GSError ConsumerSurface::SetPresentTimestamp(uint32_t sequence, const GraphicPresentTimestamp& timestamp)
520{
521    if (consumer_ == nullptr || timestamp.type == GraphicPresentTimestampType::GRAPHIC_DISPLAY_PTS_UNSUPPORTED) {
522        return GSERROR_INVALID_ARGUMENTS;
523    }
524    return consumer_->SetPresentTimestamp(sequence, timestamp);
525}
526
527void ConsumerSurface::ConsumerRequestCpuAccess(bool on)
528{
529    if (consumer_ == nullptr) {
530        return;
531    }
532    consumer_->ConsumerRequestCpuAccess(on);
533}
534
535GraphicTransformType ConsumerSurface::GetTransformHint() const
536{
537    if (producer_ == nullptr) {
538        return GraphicTransformType::GRAPHIC_ROTATE_BUTT;
539    }
540    GraphicTransformType transformHint = GraphicTransformType::GRAPHIC_ROTATE_BUTT;
541    if (producer_->GetTransformHint(transformHint) != GSERROR_OK) {
542        BLOGE("GetTransformHint failed, uniqueId: %{public}" PRIu64 ".", uniqueId_);
543        return GraphicTransformType::GRAPHIC_ROTATE_BUTT;
544    }
545    return transformHint;
546}
547
548GSError ConsumerSurface::SetTransformHint(GraphicTransformType transformHint)
549{
550    if (producer_ == nullptr) {
551        return GSERROR_INVALID_ARGUMENTS;
552    }
553    return producer_->SetTransformHint(transformHint);
554}
555
556GSError ConsumerSurface::SetSurfaceSourceType(OHSurfaceSource sourceType)
557{
558    if (producer_ == nullptr) {
559        return GSERROR_INVALID_ARGUMENTS;
560    }
561    return producer_->SetSurfaceSourceType(sourceType);
562}
563
564OHSurfaceSource ConsumerSurface::GetSurfaceSourceType() const
565{
566    if (producer_ == nullptr) {
567        return OHSurfaceSource::OH_SURFACE_SOURCE_DEFAULT;
568    }
569    OHSurfaceSource sourceType = OHSurfaceSource::OH_SURFACE_SOURCE_DEFAULT;
570    if (producer_->GetSurfaceSourceType(sourceType) != GSERROR_OK) {
571        BLOGE("GetSurfaceSourceType failed, uniqueId: %{public}" PRIu64 ".", uniqueId_);
572        return OHSurfaceSource::OH_SURFACE_SOURCE_DEFAULT;
573    }
574    return sourceType;
575}
576
577GSError ConsumerSurface::SetSurfaceAppFrameworkType(std::string appFrameworkType)
578{
579    if (producer_ == nullptr) {
580        return GSERROR_INVALID_ARGUMENTS;
581    }
582    return producer_->SetSurfaceAppFrameworkType(appFrameworkType);
583}
584
585std::string ConsumerSurface::GetSurfaceAppFrameworkType() const
586{
587    if (producer_ == nullptr) {
588        return "";
589    }
590    std::string appFrameworkType = "";
591    if (producer_->GetSurfaceAppFrameworkType(appFrameworkType) != GSERROR_OK) {
592        BLOGE("GetSurfaceAppFrameworkType failed, uniqueId: %{public}" PRIu64 ".", uniqueId_);
593        return "";
594    }
595    return appFrameworkType;
596}
597
598void ConsumerSurface::SetRequestWidthAndHeight(int32_t width, int32_t height)
599{
600    (void)width;
601    (void)height;
602}
603
604int32_t ConsumerSurface::GetRequestWidth()
605{
606    return 0;
607}
608
609int32_t ConsumerSurface::GetRequestHeight()
610{
611    return 0;
612}
613
614GSError ConsumerSurface::SetHdrWhitePointBrightness(float brightness)
615{
616    (void)brightness;
617    return GSERROR_OK;
618}
619
620GSError ConsumerSurface::SetSdrWhitePointBrightness(float brightness)
621{
622    (void)brightness;
623    return GSERROR_OK;
624}
625
626float ConsumerSurface::GetHdrWhitePointBrightness() const
627{
628    if (consumer_ == nullptr) {
629        return 0;
630    }
631    return consumer_->GetHdrWhitePointBrightness();
632}
633
634float ConsumerSurface::GetSdrWhitePointBrightness() const
635{
636    if (consumer_ == nullptr) {
637        return 0;
638    }
639    return consumer_->GetSdrWhitePointBrightness();
640}
641
642GSError ConsumerSurface::GetSurfaceBufferTransformType(sptr<SurfaceBuffer> buffer,
643    GraphicTransformType *transformType)
644{
645    if (buffer == nullptr || transformType == nullptr) {
646        return SURFACE_ERROR_INVALID_PARAM;
647    }
648    *transformType = buffer->GetSurfaceBufferTransform();
649    return GSERROR_OK;
650}
651
652GSError ConsumerSurface::IsSurfaceBufferInCache(uint32_t seqNum, bool& isInCache)
653{
654    if (consumer_ == nullptr) {
655        return SURFACE_ERROR_UNKOWN;
656    }
657    return consumer_->IsSurfaceBufferInCache(seqNum, isInCache);
658}
659
660GSError ConsumerSurface::AcquireLastFlushedBuffer(sptr<SurfaceBuffer> &buffer, sptr<SyncFence> &fence,
661    float matrix[16], uint32_t matrixSize, bool isUseNewMatrix)
662{
663    return GSERROR_NOT_SUPPORT;
664}
665
666GSError ConsumerSurface::ReleaseLastFlushedBuffer(sptr<SurfaceBuffer> buffer)
667{
668    return GSERROR_NOT_SUPPORT;
669}
670
671GSError ConsumerSurface::SetGlobalAlpha(int32_t alpha)
672{
673    (void)alpha;
674    return GSERROR_NOT_SUPPORT;
675}
676
677GSError ConsumerSurface::GetGlobalAlpha(int32_t &alpha)
678{
679    if (consumer_ == nullptr) {
680        return SURFACE_ERROR_UNKOWN;
681    }
682    return consumer_->GetGlobalAlpha(alpha);
683}
684
685uint32_t ConsumerSurface::GetAvailableBufferCount() const
686{
687    if (consumer_ == nullptr) {
688        return 0;
689    }
690    return consumer_->GetAvailableBufferCount();
691}
692} // namespace OHOS
693