1 /*
2 * Copyright (C) 2024 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 "effect_surface_adapter.h"
17
18 #include <surface_utils.h>
19 #include <sync_fence.h>
20
21 #include "effect_log.h"
22
23 namespace OHOS {
24 namespace Media {
25 namespace Effect {
26 const int32_t STRUCT_EFFECT_SURFACE_CONSTANT = 1;
27 const int32_t DESTRUCTOR_EFFECT_SURFACE_CONSTANT = 2;
28
EffectSurfaceAdapter()29 EffectSurfaceAdapter::EffectSurfaceAdapter()
30 {
31 effectSurfaceFlag_ = STRUCT_EFFECT_SURFACE_CONSTANT;
32 }
33
~EffectSurfaceAdapter()34 EffectSurfaceAdapter::~EffectSurfaceAdapter()
35 {
36 if (receiverConsumerSurface_) {
37 GSError result = receiverConsumerSurface_->UnregisterConsumerListener();
38 EFFECT_LOGI("EffectSurfaceAdapter::~EffectSurfaceAdapter UnregisterConsumerListener. result=%{public}d",
39 result);
40 effectSurfaceFlag_ = DESTRUCTOR_EFFECT_SURFACE_CONSTANT;
41 receiverConsumerSurface_ = nullptr;
42 }
43 }
44
Initialize()45 ErrorCode EffectSurfaceAdapter::Initialize()
46 {
47 receiverConsumerSurface_ = IConsumerSurface::Create("EffectSurfaceAdapter");
48 if (receiverConsumerSurface_ == nullptr) {
49 EFFECT_LOGE("Surface::CreateSurfaceAsConsumer::Create failed.");
50 return ErrorCode::ERR_IMAGE_EFFECT_RECEIVER_INIT_FAILED;
51 }
52
53 uint64_t usage = BUFFER_USAGE_CPU_HW_BOTH | BUFFER_USAGE_MEM_MMZ_CACHE;
54 if (outputSurfaceDefaultUsage_ & BUFFER_USAGE_HW_COMPOSER) {
55 usage |= BUFFER_USAGE_HW_COMPOSER;
56 }
57 (void)receiverConsumerSurface_->SetDefaultUsage(usage);
58
59 auto producer = receiverConsumerSurface_->GetProducer();
60 fromProducerSurface_ = Surface::CreateSurfaceAsProducer(producer);
61 if (fromProducerSurface_ == nullptr) {
62 EFFECT_LOGE("Surface::CreateSurfaceAsProducer failed");
63 return ErrorCode::ERR_IMAGE_EFFECT_RECEIVER_INIT_FAILED;
64 }
65
66 // register consumer listener
67 receiverConsumerSurface_->RegisterConsumerListener(this);
68
69 auto surfaceUtils = SurfaceUtils::GetInstance();
70 auto ret = surfaceUtils->Add(fromProducerSurface_->GetUniqueId(), fromProducerSurface_);
71 if (ret != SurfaceError::SURFACE_ERROR_OK) {
72 EFFECT_LOGE("add surface error: %{public}d", ret);
73 return ErrorCode::ERR_IMAGE_EFFECT_RECEIVER_INIT_FAILED;
74 }
75 EFFECT_LOGI("producer create success, unique id:%{private}llu",
76 static_cast<unsigned long long>(fromProducerSurface_->GetUniqueId()));
77
78 return ErrorCode::SUCCESS;
79 }
80
GetProducerSurface()81 sptr<Surface> EffectSurfaceAdapter::GetProducerSurface()
82 {
83 if (fromProducerSurface_) {
84 return fromProducerSurface_;
85 }
86
87 if (Initialize() != ErrorCode::SUCCESS) {
88 return nullptr;
89 }
90
91 return fromProducerSurface_;
92 }
93
CheckEffectSurface() const94 bool EffectSurfaceAdapter::CheckEffectSurface() const
95 {
96 return effectSurfaceFlag_ == STRUCT_EFFECT_SURFACE_CONSTANT;
97 }
98
AcquireConsumerSurfaceBuffer(sptr<SurfaceBuffer> & buffer,sptr<SyncFence> & syncFence,int64_t & timestamp,OHOS::Rect & damages) const99 GSError EffectSurfaceAdapter::AcquireConsumerSurfaceBuffer(sptr<SurfaceBuffer>& buffer, sptr<SyncFence>& syncFence,
100 int64_t& timestamp, OHOS::Rect& damages) const
101 {
102 CHECK_AND_RETURN_RET_LOG(receiverConsumerSurface_!= nullptr, GSERROR_NOT_INIT,
103 "EffectSurfaceAdapter::AcquireEffectSurfaceBuffer receiverConsumerSurface_ is nullptr");
104
105 return receiverConsumerSurface_->AcquireBuffer(buffer, syncFence, timestamp, damages);
106 }
107
ReleaseConsumerSurfaceBuffer(sptr<SurfaceBuffer> & buffer,const sptr<SyncFence> & syncFence) const108 GSError EffectSurfaceAdapter::ReleaseConsumerSurfaceBuffer(sptr<SurfaceBuffer>& buffer,
109 const sptr<SyncFence>& syncFence) const
110 {
111 CHECK_AND_RETURN_RET_LOG(receiverConsumerSurface_!= nullptr, GSERROR_NOT_INIT,
112 "EffectSurfaceAdapter::ReleaseEffectSurfaceBuffer receiverConsumerSurface_ is nullptr");
113
114 return receiverConsumerSurface_->ReleaseBuffer(buffer, syncFence);
115 }
116
DetachConsumerSurfaceBuffer(sptr<SurfaceBuffer> & buffer) const117 GSError EffectSurfaceAdapter::DetachConsumerSurfaceBuffer(sptr<SurfaceBuffer>& buffer) const
118 {
119 CHECK_AND_RETURN_RET_LOG(receiverConsumerSurface_!= nullptr, GSERROR_NOT_INIT,
120 "EffectSurfaceAdapter::DetachEffectSurfaceBuffer receiverConsumerSurface_ is nullptr");
121
122 return receiverConsumerSurface_->DetachBufferFromQueue(buffer, true);
123 }
124
AttachConsumerSurfaceBuffer(sptr<OHOS::SurfaceBuffer> & buffer) const125 GSError EffectSurfaceAdapter::AttachConsumerSurfaceBuffer(sptr<OHOS::SurfaceBuffer> &buffer) const
126 {
127 CHECK_AND_RETURN_RET_LOG(receiverConsumerSurface_ != nullptr, GSERROR_NOT_INIT,
128 "EffectSurfaceAdapter::AttachEffectSurfaceBuffer receiverConsumerSurface_ is nullptr");
129
130 return receiverConsumerSurface_->AttachBufferToQueue(buffer);
131 }
132
SetConsumerListener(ConsumerBufferAvailable && consumerBufferAvailable)133 ErrorCode EffectSurfaceAdapter::SetConsumerListener(ConsumerBufferAvailable &&consumerBufferAvailable)
134 {
135 if (!consumerBufferAvailable) {
136 return ErrorCode::ERR_INPUT_NULL;
137 }
138
139 consumerBufferAvailable_ = std::move(consumerBufferAvailable);
140 return ErrorCode::SUCCESS;
141 }
142
GetTransform() const143 GraphicTransformType EffectSurfaceAdapter::GetTransform() const
144 {
145 if (receiverConsumerSurface_) {
146 return receiverConsumerSurface_->GetTransform();
147 }
148
149 return GRAPHIC_ROTATE_BUTT;
150 }
151
SetOutputSurfaceDefaultUsage(uint64_t usage)152 void EffectSurfaceAdapter::SetOutputSurfaceDefaultUsage(uint64_t usage)
153 {
154 EFFECT_LOGD("SetOutputSurfaceDefaultUsage: usage=%{public}llu", static_cast<unsigned long long>(usage));
155 outputSurfaceDefaultUsage_ = usage;
156 }
157
ConsumerRequestCpuAccess(bool isCpuAccess)158 void EffectSurfaceAdapter::ConsumerRequestCpuAccess(bool isCpuAccess)
159 {
160 EFFECT_LOGD("ConsumerRequestCpuAccess: isCpuAccess=%{public}d", isCpuAccess);
161 if (receiverConsumerSurface_) {
162 receiverConsumerSurface_->ConsumerRequestCpuAccess(isCpuAccess);
163 }
164 }
165
OnBufferAvailable()166 void EffectSurfaceAdapter::OnBufferAvailable()
167 {
168 if (consumerBufferAvailable_) {
169 consumerBufferAvailable_();
170 } else {
171 EFFECT_LOGE("not register handle buffer.");
172 }
173 }
174
OnTunnelHandleChange()175 void EffectSurfaceAdapter::OnTunnelHandleChange() {}
OnGoBackground()176 void EffectSurfaceAdapter::OnGoBackground() {}
OnCleanCache(uint32_t * bufSeqNum)177 void EffectSurfaceAdapter::OnCleanCache(uint32_t* bufSeqNum)
178 {
179 (void)bufSeqNum;
180 }
181 }
182 }
183 }