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_client_producer.h"
17
18 #include "buffer_log.h"
19 #include "buffer_manager.h"
20 #include "buffer_utils.h"
21 #include "sync_fence.h"
22 #include "sync_fence_tracker.h"
23
24 #define DEFINE_MESSAGE_VARIABLES(arg, ret, opt, LOGE) \
25 MessageOption opt; \
26 MessageParcel arg; \
27 MessageParcel ret; \
28 if (!arg.WriteInterfaceToken(GetDescriptor())) { \
29 LOGE("write interface token failed"); \
30 }
31
32 #define SEND_REQUEST(COMMAND, arguments, reply, option) \
33 do { \
34 int32_t ret = Remote()->SendRequest(COMMAND, arguments, reply, option); \
35 if (ret != ERR_NONE) { \
36 BLOGN_FAILURE("SendRequest return %{public}d", ret); \
37 return GSERROR_BINDER; \
38 } \
39 } while (0)
40
41 #define SEND_REQUEST_WITH_SEQ(COMMAND, arguments, reply, option, sequence) \
42 do { \
43 int32_t ret = Remote()->SendRequest(COMMAND, arguments, reply, option); \
44 if (ret != ERR_NONE) { \
45 BLOGN_FAILURE_ID(sequence, "SendRequest return %{public}d", ret); \
46 return GSERROR_BINDER; \
47 } \
48 } while (0)
49
50 #define CHECK_RETVAL_WITH_SEQ(reply, sequence) \
51 do { \
52 int32_t ret = reply.ReadInt32(); \
53 if (ret != GSERROR_OK) { \
54 BLOGN_FAILURE_ID(sequence, "Remote return %{public}d", ret); \
55 return (GSError)ret; \
56 } \
57 } while (0)
58
59 namespace OHOS {
BufferClientProducer(const sptr<IRemoteObject> & impl)60 BufferClientProducer::BufferClientProducer(const sptr<IRemoteObject>& impl)
61 : IRemoteProxy<IBufferProducer>(impl)
62 {
63 }
64
~BufferClientProducer()65 BufferClientProducer::~BufferClientProducer()
66 {
67 }
68
RequestBuffer(const BufferRequestConfig & config,sptr<BufferExtraData> & bedata,RequestBufferReturnValue & retval)69 GSError BufferClientProducer::RequestBuffer(const BufferRequestConfig &config, sptr<BufferExtraData> &bedata,
70 RequestBufferReturnValue &retval)
71 {
72 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
73
74 WriteRequestConfig(arguments, config);
75
76 SEND_REQUEST(BUFFER_PRODUCER_REQUEST_BUFFER, arguments, reply, option);
77 CHECK_RETVAL_WITH_SEQ(reply, retval.sequence);
78
79 ReadSurfaceBufferImpl(reply, retval.sequence, retval.buffer);
80 bedata->ReadFromParcel(reply);
81 retval.fence = SyncFence::ReadFromMessageParcel(reply);
82 reply.ReadInt32Vector(&retval.deletingBuffers);
83
84 static SyncFenceTracker releaseFenceThread("Release Fence");
85 releaseFenceThread.TrackFence(retval.fence);
86
87 return GSERROR_OK;
88 }
89
CancelBuffer(uint32_t sequence,const sptr<BufferExtraData> & bedata)90 GSError BufferClientProducer::CancelBuffer(uint32_t sequence, const sptr<BufferExtraData> &bedata)
91 {
92 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
93
94 arguments.WriteUint32(sequence);
95 bedata->WriteToParcel(arguments);
96
97 SEND_REQUEST_WITH_SEQ(BUFFER_PRODUCER_CANCEL_BUFFER, arguments, reply, option, sequence);
98 CHECK_RETVAL_WITH_SEQ(reply, sequence);
99
100 return GSERROR_OK;
101 }
102
FlushBuffer(uint32_t sequence,const sptr<BufferExtraData> & bedata,const sptr<SyncFence> & fence,BufferFlushConfig & config)103 GSError BufferClientProducer::FlushBuffer(uint32_t sequence, const sptr<BufferExtraData> &bedata,
104 const sptr<SyncFence>& fence, BufferFlushConfig &config)
105 {
106 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
107
108 arguments.WriteUint32(sequence);
109 bedata->WriteToParcel(arguments);
110 fence->WriteToMessageParcel(arguments);
111 WriteFlushConfig(arguments, config);
112
113 SEND_REQUEST_WITH_SEQ(BUFFER_PRODUCER_FLUSH_BUFFER, arguments, reply, option, sequence);
114 CHECK_RETVAL_WITH_SEQ(reply, sequence);
115
116 static SyncFenceTracker acquireFenceThread("Acquire Fence");
117 acquireFenceThread.TrackFence(fence);
118
119 return GSERROR_OK;
120 }
121
AttachBuffer(sptr<SurfaceBuffer> & buffer)122 GSError BufferClientProducer::AttachBuffer(sptr<SurfaceBuffer>& buffer)
123 {
124 return GSERROR_NOT_SUPPORT;
125 }
126
DetachBuffer(sptr<SurfaceBuffer> & buffer)127 GSError BufferClientProducer::DetachBuffer(sptr<SurfaceBuffer>& buffer)
128 {
129 return GSERROR_NOT_SUPPORT;
130 }
131
RegisterReleaseListener(OnReleaseFunc func)132 GSError BufferClientProducer::RegisterReleaseListener(OnReleaseFunc func)
133 {
134 return GSERROR_NOT_SUPPORT;
135 }
136
GetQueueSize()137 uint32_t BufferClientProducer::GetQueueSize()
138 {
139 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
140
141 SEND_REQUEST(BUFFER_PRODUCER_GET_QUEUE_SIZE, arguments, reply, option);
142
143 return reply.ReadUint32();
144 }
145
SetQueueSize(uint32_t queueSize)146 GSError BufferClientProducer::SetQueueSize(uint32_t queueSize)
147 {
148 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
149
150 arguments.WriteInt32(queueSize);
151
152 SEND_REQUEST(BUFFER_PRODUCER_SET_QUEUE_SIZE, arguments, reply, option);
153 int32_t ret = reply.ReadInt32();
154 if (ret != GSERROR_OK) {
155 BLOGN_FAILURE("Remote return %{public}d", ret);
156 return (GSError)ret;
157 }
158
159 return GSERROR_OK;
160 }
161
GetName(std::string & name)162 GSError BufferClientProducer::GetName(std::string &name)
163 {
164 {
165 std::lock_guard<std::mutex> lockGuard(mutex_);
166 if (name_ != "not init") {
167 name = name_;
168 return GSERROR_OK;
169 }
170 }
171 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
172
173 SEND_REQUEST(BUFFER_PRODUCER_GET_NAME, arguments, reply, option);
174 int32_t ret = reply.ReadInt32();
175 if (ret != GSERROR_OK) {
176 BLOGN_FAILURE("Remote return %{public}d", ret);
177 return static_cast<GSError>(ret);
178 }
179 if (reply.ReadString(name) == false) {
180 BLOGN_FAILURE("reply.ReadString return false");
181 return GSERROR_BINDER;
182 }
183 {
184 std::lock_guard<std::mutex> lockGuard(mutex_);
185 name_ = name;
186 }
187 return static_cast<GSError>(ret);
188 }
189
GetUniqueId()190 uint64_t BufferClientProducer::GetUniqueId()
191 {
192 {
193 std::lock_guard<std::mutex> lockGuard(mutex_);
194 if (uniqueId_ != 0) {
195 return uniqueId_;
196 }
197 }
198 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
199 SEND_REQUEST(BUFFER_PRODUCER_GET_UNIQUE_ID, arguments, reply, option);
200 {
201 std::lock_guard<std::mutex> lockGuard(mutex_);
202 uniqueId_ = reply.ReadUint64();
203 }
204 return uniqueId_;
205 }
206
GetNameAndUniqueId(std::string & name,uint64_t & uniqueId)207 GSError BufferClientProducer::GetNameAndUniqueId(std::string& name, uint64_t& uniqueId)
208 {
209 {
210 std::lock_guard<std::mutex> lockGuard(mutex_);
211 if (uniqueId_ != 0 && name_ != "not init") {
212 uniqueId = uniqueId_;
213 name = name_;
214 return GSERROR_OK;
215 }
216 }
217 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
218
219 SEND_REQUEST(BUFFER_PRODUCER_GET_NAMEANDUNIQUEDID, arguments, reply, option);
220 int32_t ret = reply.ReadInt32();
221 if (ret != GSERROR_OK) {
222 BLOGN_FAILURE("Remote return %{public}d", ret);
223 return static_cast<GSError>(ret);
224 }
225 if (reply.ReadString(name) == false) {
226 BLOGN_FAILURE("reply.ReadString return false");
227 return GSERROR_BINDER;
228 }
229
230 uniqueId = reply.ReadUint64();
231 {
232 std::lock_guard<std::mutex> lockGuard(mutex_);
233 name_ = name;
234 uniqueId_ = uniqueId;
235 }
236 return static_cast<GSError>(ret);
237 }
238
GetDefaultWidth()239 int32_t BufferClientProducer::GetDefaultWidth()
240 {
241 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
242
243 SEND_REQUEST(BUFFER_PRODUCER_GET_DEFAULT_WIDTH, arguments, reply, option);
244
245 return reply.ReadInt32();
246 }
247
GetDefaultHeight()248 int32_t BufferClientProducer::GetDefaultHeight()
249 {
250 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
251
252 SEND_REQUEST(BUFFER_PRODUCER_GET_DEFAULT_HEIGHT, arguments, reply, option);
253
254 return reply.ReadInt32();
255 }
256
GetDefaultUsage()257 uint32_t BufferClientProducer::GetDefaultUsage()
258 {
259 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
260
261 SEND_REQUEST(BUFFER_PRODUCER_GET_DEFAULT_USAGE, arguments, reply, option);
262
263 return reply.ReadUint32();
264 }
265
CleanCache()266 GSError BufferClientProducer::CleanCache()
267 {
268 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
269
270 SEND_REQUEST(BUFFER_PRODUCER_CLEAN_CACHE, arguments, reply, option);
271 int32_t ret = reply.ReadInt32();
272 if (ret != GSERROR_OK) {
273 BLOGN_FAILURE("Remote return %{public}d", ret);
274 return (GSError)ret;
275 }
276
277 return GSERROR_OK;
278 }
279
GoBackground()280 GSError BufferClientProducer::GoBackground()
281 {
282 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
283
284 SEND_REQUEST(BUFFER_PRODUCER_GO_BACKGROUND, arguments, reply, option);
285 int32_t ret = reply.ReadInt32();
286 if (ret != GSERROR_OK) {
287 BLOGN_FAILURE("Remote return %{public}d", ret);
288 return (GSError)ret;
289 }
290
291 return GSERROR_OK;
292 }
293
SetTransform(GraphicTransformType transform)294 GSError BufferClientProducer::SetTransform(GraphicTransformType transform)
295 {
296 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
297
298 arguments.WriteUint32(static_cast<uint32_t>(transform));
299
300 SEND_REQUEST(BUFFER_PRODUCER_SET_TRANSFORM, arguments, reply, option);
301 int32_t ret = reply.ReadInt32();
302 if (ret != GSERROR_OK) {
303 BLOGN_FAILURE("Remote return %{public}d", ret);
304 return (GSError)ret;
305 }
306
307 return GSERROR_OK;
308 }
309
IsSupportedAlloc(const std::vector<BufferVerifyAllocInfo> & infos,std::vector<bool> & supporteds)310 GSError BufferClientProducer::IsSupportedAlloc(const std::vector<BufferVerifyAllocInfo> &infos,
311 std::vector<bool> &supporteds)
312 {
313 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
314
315 WriteVerifyAllocInfo(arguments, infos);
316
317 SEND_REQUEST(BUFFER_PRODUCER_IS_SUPPORTED_ALLOC, arguments, reply, option);
318 int32_t ret = reply.ReadInt32();
319 if (ret != GSERROR_OK) {
320 BLOGN_FAILURE("Remote return %{public}d", ret);
321 return static_cast<GSError>(ret);
322 }
323
324 if (reply.ReadBoolVector(&supporteds) == false) {
325 BLOGN_FAILURE("reply.ReadBoolVector return false");
326 return GSERROR_BINDER;
327 }
328
329 return static_cast<GSError>(ret);
330 }
331
Disconnect()332 GSError BufferClientProducer::Disconnect()
333 {
334 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
335
336 SEND_REQUEST(BUFFER_PRODUCER_DISCONNECT, arguments, reply, option);
337 int32_t ret = reply.ReadInt32();
338 if (ret != GSERROR_OK) {
339 BLOGN_FAILURE("Remote return %{public}d", ret);
340 return static_cast<GSError>(ret);
341 }
342 return GSERROR_OK;
343 }
344
SetScalingMode(uint32_t sequence,ScalingMode scalingMode)345 GSError BufferClientProducer::SetScalingMode(uint32_t sequence, ScalingMode scalingMode)
346 {
347 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
348 arguments.WriteUint32(sequence);
349 arguments.WriteInt32(static_cast<int32_t>(scalingMode));
350 SEND_REQUEST(BUFFER_PRODUCER_SET_SCALING_MODE, arguments, reply, option);
351 int32_t ret = reply.ReadInt32();
352 if (ret != GSERROR_OK) {
353 BLOGN_FAILURE("Remote return %{public}d", ret);
354 return (GSError)ret;
355 }
356
357 return GSERROR_OK;
358 }
359
SetMetaData(uint32_t sequence,const std::vector<GraphicHDRMetaData> & metaData)360 GSError BufferClientProducer::SetMetaData(uint32_t sequence, const std::vector<GraphicHDRMetaData> &metaData)
361 {
362 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
363 arguments.WriteUint32(sequence);
364 WriteHDRMetaData(arguments, metaData);
365 SEND_REQUEST(BUFFER_PRODUCER_SET_METADATA, arguments, reply, option);
366 int32_t ret = reply.ReadInt32();
367 if (ret != GSERROR_OK) {
368 BLOGN_FAILURE("Remote return %{public}d", ret);
369 return (GSError)ret;
370 }
371
372 return GSERROR_OK;
373 }
374
SetMetaDataSet(uint32_t sequence,GraphicHDRMetadataKey key,const std::vector<uint8_t> & metaData)375 GSError BufferClientProducer::SetMetaDataSet(uint32_t sequence, GraphicHDRMetadataKey key,
376 const std::vector<uint8_t> &metaData)
377 {
378 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
379 arguments.WriteUint32(sequence);
380 arguments.WriteUint32(static_cast<uint32_t>(key));
381 WriteHDRMetaDataSet(arguments, metaData);
382 SEND_REQUEST(BUFFER_PRODUCER_SET_METADATASET, arguments, reply, option);
383 int32_t ret = reply.ReadInt32();
384 if (ret != GSERROR_OK) {
385 BLOGN_FAILURE("Remote return %{public}d", ret);
386 return (GSError)ret;
387 }
388
389 return GSERROR_OK;
390 }
391
SetTunnelHandle(const GraphicExtDataHandle * handle)392 GSError BufferClientProducer::SetTunnelHandle(const GraphicExtDataHandle *handle)
393 {
394 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
395 if (handle == nullptr) {
396 arguments.WriteBool(false);
397 } else {
398 arguments.WriteBool(true);
399 WriteExtDataHandle(arguments, handle);
400 }
401 SEND_REQUEST(BUFFER_PRODUCER_SET_TUNNEL_HANDLE, arguments, reply, option);
402 int32_t ret = reply.ReadInt32();
403 if (ret != GSERROR_OK) {
404 BLOGN_FAILURE("Remote return %{public}d", ret);
405 return (GSError)ret;
406 }
407 return GSERROR_OK;
408 }
409
GetPresentTimestamp(uint32_t sequence,GraphicPresentTimestampType type,int64_t & time)410 GSError BufferClientProducer::GetPresentTimestamp(uint32_t sequence, GraphicPresentTimestampType type, int64_t &time)
411 {
412 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
413 arguments.WriteUint32(sequence);
414 arguments.WriteUint32(static_cast<uint32_t>(type));
415 SEND_REQUEST(BUFFER_PRODUCER_GET_PRESENT_TIMESTAMP, arguments, reply, option);
416 int32_t ret = reply.ReadInt32();
417 if (ret != GSERROR_OK) {
418 BLOGN_FAILURE("Remote return %{public}d", ret);
419 return static_cast<GSError>(ret);
420 }
421 time = reply.ReadInt64();
422 return static_cast<GSError>(ret);
423 }
424
GetNativeSurface()425 sptr<NativeSurface> BufferClientProducer::GetNativeSurface()
426 {
427 BLOGND("BufferClientProducer::GetNativeSurface not support.");
428 return nullptr;
429 }
430 }; // namespace OHOS
431