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 <iremote_stub.h>
19 #include "buffer_log.h"
20 #include "buffer_utils.h"
21 #include "sync_fence.h"
22 #include "message_option.h"
23 #include "securec.h"
24
25 #define DEFINE_MESSAGE_VARIABLES(arg, ret, opt, LOGE) \
26 MessageOption opt; \
27 MessageParcel arg; \
28 MessageParcel ret; \
29 if (!(arg).WriteInterfaceToken(GetDescriptor())) { \
30 LOGE("write interface token failed"); \
31 }
32
33 #define SEND_REQUEST(COMMAND, arguments, reply, option) \
34 do { \
35 int32_t ret = Remote()->SendRequest(COMMAND, arguments, reply, option); \
36 if (ret != ERR_NONE) { \
37 BLOGN_FAILURE("SendRequest return %{public}d", ret); \
38 return GSERROR_BINDER; \
39 } \
40 } while (0)
41
42 #define SEND_REQUEST_WITH_SEQ(COMMAND, arguments, reply, option, sequence) \
43 do { \
44 int32_t ret = Remote()->SendRequest(COMMAND, arguments, reply, option); \
45 if (ret != ERR_NONE) { \
46 BLOGN_FAILURE_ID(sequence, "SendRequest return %{public}d", ret); \
47 return GSERROR_BINDER; \
48 } \
49 } while (0)
50
51 #define CHECK_RETVAL_WITH_SEQ(reply, sequence) \
52 do { \
53 int32_t ret = (reply).ReadInt32(); \
54 if (ret != GSERROR_OK) { \
55 BLOGN_FAILURE_ID(sequence, "Remote return %{public}d", ret); \
56 return (GSError)ret; \
57 } \
58 } while (0)
59
60 namespace OHOS {
61 namespace {
62 int32_t g_CancelBufferConsecutiveFailedCount = 0;
63 constexpr int32_t MAX_COUNT = 2;
64 }
BufferClientProducer(const sptr<IRemoteObject> & impl)65 BufferClientProducer::BufferClientProducer(const sptr<IRemoteObject>& impl)
66 : IRemoteProxy<IBufferProducer>(impl)
67 {
68 }
69
~BufferClientProducer()70 BufferClientProducer::~BufferClientProducer()
71 {
72 }
73
RequestBuffer(const BufferRequestConfig & config,sptr<BufferExtraData> & bedata,RequestBufferReturnValue & retval)74 GSError BufferClientProducer::RequestBuffer(const BufferRequestConfig &config, sptr<BufferExtraData> &bedata,
75 RequestBufferReturnValue &retval)
76 {
77 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
78
79 WriteRequestConfig(arguments, config);
80
81 SEND_REQUEST(BUFFER_PRODUCER_REQUEST_BUFFER, arguments, reply, option);
82 int32_t retCode = reply.ReadInt32();
83 if (retCode != GSERROR_OK) {
84 BLOGND("Remote return %{public}d", retCode);
85 return (GSError)retCode;
86 }
87
88 GSError ret = ReadSurfaceBufferImpl(reply, retval.sequence, retval.buffer);
89 if (ret != GSERROR_OK) {
90 BLOGN_FAILURE("Read surface buffer impl failed, return %{public}d", ret);
91 return ret;
92 }
93
94 ret = bedata->ReadFromParcel(reply);
95 if (ret != GSERROR_OK) {
96 BLOGN_FAILURE("Read extra data from parcel failed, return %{public}d", ret);
97 return ret;
98 }
99 retval.fence = SyncFence::ReadFromMessageParcel(reply);
100 reply.ReadInt32Vector(&retval.deletingBuffers);
101
102 return GSERROR_OK;
103 }
104
GetLastFlushedBuffer(sptr<SurfaceBuffer> & buffer,sptr<SyncFence> & fence,float matrix[16])105 GSError BufferClientProducer::GetLastFlushedBuffer(sptr<SurfaceBuffer>& buffer,
106 sptr<SyncFence>& fence, float matrix[16])
107 {
108 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
109
110 SEND_REQUEST(BUFFER_PRODUCER_GET_LAST_FLUSHED_BUFFER, arguments, reply, option);
111 int32_t retCode = reply.ReadInt32();
112 if (retCode != GSERROR_OK) {
113 BLOGND("Remote return %{public}d", retCode);
114 return (GSError)retCode;
115 }
116 uint32_t sequence;
117 GSError ret = ReadSurfaceBufferImpl(reply, sequence, buffer);
118 if (ret != GSERROR_OK) {
119 BLOGN_FAILURE("Read surface buffer impl failed, return %{public}d", ret);
120 return ret;
121 }
122
123 fence = SyncFence::ReadFromMessageParcel(reply);
124 std::vector<float> readMatrixVector;
125 reply.ReadFloatVector(&readMatrixVector);
126 if (memcpy_s(matrix, readMatrixVector.size() * sizeof(float),
127 readMatrixVector.data(), readMatrixVector.size() * sizeof(float)) != EOK) {
128 BLOGN_FAILURE("memcpy_s fail");
129 return GSERROR_API_FAILED;
130 }
131 return GSERROR_OK;
132 }
133
CancelBuffer(uint32_t sequence,const sptr<BufferExtraData> & bedata)134 GSError BufferClientProducer::CancelBuffer(uint32_t sequence, const sptr<BufferExtraData> &bedata)
135 {
136 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
137
138 arguments.WriteUint32(sequence);
139 bedata->WriteToParcel(arguments);
140
141 SEND_REQUEST_WITH_SEQ(BUFFER_PRODUCER_CANCEL_BUFFER, arguments, reply, option, sequence);
142 int32_t ret = reply.ReadInt32();
143 if (ret != GSERROR_OK) {
144 g_CancelBufferConsecutiveFailedCount++;
145 if (g_CancelBufferConsecutiveFailedCount < MAX_COUNT) {
146 BLOGN_FAILURE_ID(sequence, "Remote return %{public}d", ret);
147 }
148 return (GSError)ret;
149 }
150 g_CancelBufferConsecutiveFailedCount = 0;
151 return GSERROR_OK;
152 }
153
FlushBuffer(uint32_t sequence,const sptr<BufferExtraData> & bedata,const sptr<SyncFence> & fence,BufferFlushConfigWithDamages & config)154 GSError BufferClientProducer::FlushBuffer(uint32_t sequence, const sptr<BufferExtraData> &bedata,
155 const sptr<SyncFence>& fence, BufferFlushConfigWithDamages &config)
156 {
157 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
158
159 arguments.WriteUint32(sequence);
160 bedata->WriteToParcel(arguments);
161 fence->WriteToMessageParcel(arguments);
162 WriteFlushConfig(arguments, config);
163
164 SEND_REQUEST_WITH_SEQ(BUFFER_PRODUCER_FLUSH_BUFFER, arguments, reply, option, sequence);
165 CHECK_RETVAL_WITH_SEQ(reply, sequence);
166
167 return GSERROR_OK;
168 }
169
AttachBuffer(sptr<SurfaceBuffer> & buffer)170 GSError BufferClientProducer::AttachBuffer(sptr<SurfaceBuffer>& buffer)
171 {
172 return GSERROR_NOT_SUPPORT;
173 }
174
AttachBuffer(sptr<SurfaceBuffer> & buffer,int32_t timeOut)175 GSError BufferClientProducer::AttachBuffer(sptr<SurfaceBuffer>& buffer, int32_t timeOut)
176 {
177 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
178 uint32_t sequence = buffer->GetSeqNum();
179 WriteSurfaceBufferImpl(arguments, sequence, buffer);
180 arguments.WriteInt32(timeOut);
181 SEND_REQUEST_WITH_SEQ(BUFFER_PRODUCER_ATTACH_BUFFER, arguments, reply, option, sequence);
182 CHECK_RETVAL_WITH_SEQ(reply, sequence);
183 return GSERROR_OK;
184 }
185
DetachBuffer(sptr<SurfaceBuffer> & buffer)186 GSError BufferClientProducer::DetachBuffer(sptr<SurfaceBuffer>& buffer)
187 {
188 return GSERROR_NOT_SUPPORT;
189 }
190
RegisterReleaseListener(sptr<IProducerListener> listener)191 GSError BufferClientProducer::RegisterReleaseListener(sptr<IProducerListener> listener)
192 {
193 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
194
195 arguments.WriteRemoteObject(listener->AsObject());
196
197 SEND_REQUEST(BUFFER_PRODUCER_REGISTER_RELEASE_LISTENER, arguments, reply, option);
198 int32_t ret = reply.ReadInt32();
199 if (ret != GSERROR_OK) {
200 BLOGN_FAILURE("Remote return %{public}d", ret);
201 return (GSError)ret;
202 }
203 return GSERROR_OK;
204 }
205
UnRegisterReleaseListener()206 GSError BufferClientProducer::UnRegisterReleaseListener()
207 {
208 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
209 SEND_REQUEST(BUFFER_PRODUCER_UNREGISTER_RELEASE_LISTENER, arguments, reply, option);
210 int32_t ret = reply.ReadInt32();
211 if (ret != GSERROR_OK) {
212 BLOGN_FAILURE("Remote return %{public}d", ret);
213 return (GSError)ret;
214 }
215 return GSERROR_OK;
216 }
217
GetQueueSize()218 uint32_t BufferClientProducer::GetQueueSize()
219 {
220 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
221
222 SEND_REQUEST(BUFFER_PRODUCER_GET_QUEUE_SIZE, arguments, reply, option);
223
224 return reply.ReadUint32();
225 }
226
SetQueueSize(uint32_t queueSize)227 GSError BufferClientProducer::SetQueueSize(uint32_t queueSize)
228 {
229 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
230
231 arguments.WriteInt32(queueSize);
232
233 SEND_REQUEST(BUFFER_PRODUCER_SET_QUEUE_SIZE, arguments, reply, option);
234 int32_t ret = reply.ReadInt32();
235 if (ret != GSERROR_OK) {
236 BLOGN_FAILURE("Remote return %{public}d", ret);
237 return (GSError)ret;
238 }
239
240 return GSERROR_OK;
241 }
242
GetName(std::string & name)243 GSError BufferClientProducer::GetName(std::string &name)
244 {
245 {
246 std::lock_guard<std::mutex> lockGuard(mutex_);
247 if (name_ != "not init") {
248 name = name_;
249 return GSERROR_OK;
250 }
251 }
252 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
253
254 SEND_REQUEST(BUFFER_PRODUCER_GET_NAME, arguments, reply, option);
255 int32_t ret = reply.ReadInt32();
256 if (ret != GSERROR_OK) {
257 BLOGN_FAILURE("Remote return %{public}d", ret);
258 return static_cast<GSError>(ret);
259 }
260 if (reply.ReadString(name) == false) {
261 BLOGN_FAILURE("reply.ReadString return false");
262 return GSERROR_BINDER;
263 }
264 {
265 std::lock_guard<std::mutex> lockGuard(mutex_);
266 name_ = name;
267 }
268 return static_cast<GSError>(ret);
269 }
270
GetUniqueId()271 uint64_t BufferClientProducer::GetUniqueId()
272 {
273 {
274 std::lock_guard<std::mutex> lockGuard(mutex_);
275 if (uniqueId_ != 0) {
276 return uniqueId_;
277 }
278 }
279 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
280 SEND_REQUEST(BUFFER_PRODUCER_GET_UNIQUE_ID, arguments, reply, option);
281 {
282 std::lock_guard<std::mutex> lockGuard(mutex_);
283 uniqueId_ = reply.ReadUint64();
284 }
285 return uniqueId_;
286 }
287
GetNameAndUniqueId(std::string & name,uint64_t & uniqueId)288 GSError BufferClientProducer::GetNameAndUniqueId(std::string& name, uint64_t& uniqueId)
289 {
290 {
291 std::lock_guard<std::mutex> lockGuard(mutex_);
292 if (uniqueId_ != 0 && name_ != "not init") {
293 uniqueId = uniqueId_;
294 name = name_;
295 return GSERROR_OK;
296 }
297 }
298 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
299
300 SEND_REQUEST(BUFFER_PRODUCER_GET_NAMEANDUNIQUEDID, arguments, reply, option);
301 int32_t ret = reply.ReadInt32();
302 if (ret != GSERROR_OK) {
303 BLOGN_FAILURE("Remote return %{public}d", ret);
304 return static_cast<GSError>(ret);
305 }
306 if (reply.ReadString(name) == false) {
307 BLOGN_FAILURE("reply.ReadString return false");
308 return GSERROR_BINDER;
309 }
310
311 uniqueId = reply.ReadUint64();
312 {
313 std::lock_guard<std::mutex> lockGuard(mutex_);
314 name_ = name;
315 uniqueId_ = uniqueId;
316 }
317 return static_cast<GSError>(ret);
318 }
319
GetDefaultWidth()320 int32_t BufferClientProducer::GetDefaultWidth()
321 {
322 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
323
324 SEND_REQUEST(BUFFER_PRODUCER_GET_DEFAULT_WIDTH, arguments, reply, option);
325
326 return reply.ReadInt32();
327 }
328
GetDefaultHeight()329 int32_t BufferClientProducer::GetDefaultHeight()
330 {
331 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
332
333 SEND_REQUEST(BUFFER_PRODUCER_GET_DEFAULT_HEIGHT, arguments, reply, option);
334
335 return reply.ReadInt32();
336 }
337
GetDefaultUsage()338 uint32_t BufferClientProducer::GetDefaultUsage()
339 {
340 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
341
342 SEND_REQUEST(BUFFER_PRODUCER_GET_DEFAULT_USAGE, arguments, reply, option);
343
344 return reply.ReadUint32();
345 }
346
CleanCache()347 GSError BufferClientProducer::CleanCache()
348 {
349 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
350
351 SEND_REQUEST(BUFFER_PRODUCER_CLEAN_CACHE, arguments, reply, option);
352 int32_t ret = reply.ReadInt32();
353 if (ret != GSERROR_OK) {
354 BLOGN_FAILURE("Remote return %{public}d", ret);
355 return (GSError)ret;
356 }
357
358 return GSERROR_OK;
359 }
360
GoBackground()361 GSError BufferClientProducer::GoBackground()
362 {
363 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
364
365 SEND_REQUEST(BUFFER_PRODUCER_GO_BACKGROUND, 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
SetTransform(GraphicTransformType transform)375 GSError BufferClientProducer::SetTransform(GraphicTransformType transform)
376 {
377 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
378
379 arguments.WriteUint32(static_cast<uint32_t>(transform));
380
381 SEND_REQUEST(BUFFER_PRODUCER_SET_TRANSFORM, arguments, reply, option);
382 int32_t ret = reply.ReadInt32();
383 if (ret != GSERROR_OK) {
384 BLOGN_FAILURE("Remote return %{public}d", ret);
385 return (GSError)ret;
386 }
387
388 return GSERROR_OK;
389 }
390
IsSupportedAlloc(const std::vector<BufferVerifyAllocInfo> & infos,std::vector<bool> & supporteds)391 GSError BufferClientProducer::IsSupportedAlloc(const std::vector<BufferVerifyAllocInfo> &infos,
392 std::vector<bool> &supporteds)
393 {
394 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
395
396 WriteVerifyAllocInfo(arguments, infos);
397
398 SEND_REQUEST(BUFFER_PRODUCER_IS_SUPPORTED_ALLOC, arguments, reply, option);
399 int32_t ret = reply.ReadInt32();
400 if (ret != GSERROR_OK) {
401 BLOGN_FAILURE("Remote return %{public}d", ret);
402 return static_cast<GSError>(ret);
403 }
404
405 if (reply.ReadBoolVector(&supporteds) == false) {
406 BLOGN_FAILURE("reply.ReadBoolVector return false");
407 return GSERROR_BINDER;
408 }
409
410 return static_cast<GSError>(ret);
411 }
412
Disconnect()413 GSError BufferClientProducer::Disconnect()
414 {
415 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
416
417 SEND_REQUEST(BUFFER_PRODUCER_DISCONNECT, arguments, reply, option);
418 int32_t ret = reply.ReadInt32();
419 if (ret != GSERROR_OK) {
420 BLOGN_FAILURE("Remote return %{public}d", ret);
421 return static_cast<GSError>(ret);
422 }
423 return GSERROR_OK;
424 }
425
SetScalingMode(uint32_t sequence,ScalingMode scalingMode)426 GSError BufferClientProducer::SetScalingMode(uint32_t sequence, ScalingMode scalingMode)
427 {
428 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
429 arguments.WriteUint32(sequence);
430 arguments.WriteInt32(static_cast<int32_t>(scalingMode));
431 SEND_REQUEST(BUFFER_PRODUCER_SET_SCALING_MODE, arguments, reply, option);
432 int32_t ret = reply.ReadInt32();
433 if (ret != GSERROR_OK) {
434 BLOGN_FAILURE("Remote return %{public}d", ret);
435 return (GSError)ret;
436 }
437
438 return GSERROR_OK;
439 }
440
SetMetaData(uint32_t sequence,const std::vector<GraphicHDRMetaData> & metaData)441 GSError BufferClientProducer::SetMetaData(uint32_t sequence, const std::vector<GraphicHDRMetaData> &metaData)
442 {
443 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
444 arguments.WriteUint32(sequence);
445 WriteHDRMetaData(arguments, metaData);
446 SEND_REQUEST(BUFFER_PRODUCER_SET_METADATA, arguments, reply, option);
447 int32_t ret = reply.ReadInt32();
448 if (ret != GSERROR_OK) {
449 BLOGN_FAILURE("Remote return %{public}d", ret);
450 return (GSError)ret;
451 }
452
453 return GSERROR_OK;
454 }
455
SetMetaDataSet(uint32_t sequence,GraphicHDRMetadataKey key,const std::vector<uint8_t> & metaData)456 GSError BufferClientProducer::SetMetaDataSet(uint32_t sequence, GraphicHDRMetadataKey key,
457 const std::vector<uint8_t> &metaData)
458 {
459 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
460 arguments.WriteUint32(sequence);
461 arguments.WriteUint32(static_cast<uint32_t>(key));
462 WriteHDRMetaDataSet(arguments, metaData);
463 SEND_REQUEST(BUFFER_PRODUCER_SET_METADATASET, arguments, reply, option);
464 int32_t ret = reply.ReadInt32();
465 if (ret != GSERROR_OK) {
466 BLOGN_FAILURE("Remote return %{public}d", ret);
467 return (GSError)ret;
468 }
469
470 return GSERROR_OK;
471 }
472
SetTunnelHandle(const GraphicExtDataHandle * handle)473 GSError BufferClientProducer::SetTunnelHandle(const GraphicExtDataHandle *handle)
474 {
475 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
476 if (handle == nullptr) {
477 arguments.WriteBool(false);
478 } else {
479 arguments.WriteBool(true);
480 WriteExtDataHandle(arguments, handle);
481 }
482 SEND_REQUEST(BUFFER_PRODUCER_SET_TUNNEL_HANDLE, arguments, reply, option);
483 int32_t ret = reply.ReadInt32();
484 if (ret != GSERROR_OK) {
485 BLOGN_FAILURE("Remote return %{public}d", ret);
486 return (GSError)ret;
487 }
488 return GSERROR_OK;
489 }
490
GetPresentTimestamp(uint32_t sequence,GraphicPresentTimestampType type,int64_t & time)491 GSError BufferClientProducer::GetPresentTimestamp(uint32_t sequence, GraphicPresentTimestampType type, int64_t &time)
492 {
493 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
494 arguments.WriteUint32(sequence);
495 arguments.WriteUint32(static_cast<uint32_t>(type));
496 SEND_REQUEST(BUFFER_PRODUCER_GET_PRESENT_TIMESTAMP, arguments, reply, option);
497 int32_t ret = reply.ReadInt32();
498 if (ret != GSERROR_OK) {
499 BLOGN_FAILURE("Remote return %{public}d", ret);
500 return static_cast<GSError>(ret);
501 }
502 time = reply.ReadInt64();
503 return static_cast<GSError>(ret);
504 }
505
GetNativeSurface()506 sptr<NativeSurface> BufferClientProducer::GetNativeSurface()
507 {
508 BLOGND("BufferClientProducer::GetNativeSurface not support.");
509 return nullptr;
510 }
511
SendDeathRecipientObject()512 GSError BufferClientProducer::SendDeathRecipientObject()
513 {
514 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
515 token_ = new IRemoteStub<IBufferProducerToken>();
516 arguments.WriteRemoteObject(token_->AsObject());
517 SEND_REQUEST(BUFFER_PRODUCER_REGISTER_DEATH_RECIPIENT, arguments, reply, option);
518
519 int32_t ret = reply.ReadInt32();
520 if (ret != GSERROR_OK) {
521 BLOGN_FAILURE("Remote return %{public}d", ret);
522 return static_cast<GSError>(ret);
523 }
524 return GSERROR_OK;
525 }
526
GetTransform(GraphicTransformType & transform)527 GSError BufferClientProducer::GetTransform(GraphicTransformType &transform)
528 {
529 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
530 SEND_REQUEST(BUFFER_PRODUCER_GET_TRANSFORM, arguments, reply, option);
531
532 auto ret = static_cast<GSError>(reply.ReadInt32());
533 if (ret != GSERROR_OK) {
534 BLOGN_FAILURE("Remote return %{public}d", static_cast<int>(ret));
535 return ret;
536 }
537 transform = static_cast<GraphicTransformType>(reply.ReadUint32());
538 return GSERROR_OK;
539 }
540 }; // namespace OHOS
541