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 "message_option.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 GSError ret = ReadSurfaceBufferImpl(reply, retval.sequence, retval.buffer);
80 if (ret != GSERROR_OK) {
81 BLOGN_FAILURE("Read surface buffer impl failed, return %{public}d", ret);
82 return ret;
83 }
84
85 ret = bedata->ReadFromParcel(reply);
86 if (ret != GSERROR_OK) {
87 BLOGN_FAILURE("Read extra data from parcel failed, return %{public}d", ret);
88 return ret;
89 }
90 retval.fence = SyncFence::ReadFromMessageParcel(reply);
91 reply.ReadInt32Vector(&retval.deletingBuffers);
92
93 return GSERROR_OK;
94 }
95
CancelBuffer(uint32_t sequence,const sptr<BufferExtraData> & bedata)96 GSError BufferClientProducer::CancelBuffer(uint32_t sequence, const sptr<BufferExtraData> &bedata)
97 {
98 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
99
100 arguments.WriteUint32(sequence);
101 bedata->WriteToParcel(arguments);
102
103 SEND_REQUEST_WITH_SEQ(BUFFER_PRODUCER_CANCEL_BUFFER, arguments, reply, option, sequence);
104 CHECK_RETVAL_WITH_SEQ(reply, sequence);
105
106 return GSERROR_OK;
107 }
108
FlushBuffer(uint32_t sequence,const sptr<BufferExtraData> & bedata,const sptr<SyncFence> & fence,BufferFlushConfigWithDamages & config)109 GSError BufferClientProducer::FlushBuffer(uint32_t sequence, const sptr<BufferExtraData> &bedata,
110 const sptr<SyncFence>& fence, BufferFlushConfigWithDamages &config)
111 {
112 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
113
114 arguments.WriteUint32(sequence);
115 bedata->WriteToParcel(arguments);
116 fence->WriteToMessageParcel(arguments);
117 WriteFlushConfig(arguments, config);
118
119 SEND_REQUEST_WITH_SEQ(BUFFER_PRODUCER_FLUSH_BUFFER, arguments, reply, option, sequence);
120 CHECK_RETVAL_WITH_SEQ(reply, sequence);
121
122 return GSERROR_OK;
123 }
124
AttachBuffer(sptr<SurfaceBuffer> & buffer)125 GSError BufferClientProducer::AttachBuffer(sptr<SurfaceBuffer>& buffer)
126 {
127 return GSERROR_NOT_SUPPORT;
128 }
129
DetachBuffer(sptr<SurfaceBuffer> & buffer)130 GSError BufferClientProducer::DetachBuffer(sptr<SurfaceBuffer>& buffer)
131 {
132 return GSERROR_NOT_SUPPORT;
133 }
134
RegisterReleaseListener(sptr<IProducerListener> listener)135 GSError BufferClientProducer::RegisterReleaseListener(sptr<IProducerListener> listener)
136 {
137 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
138
139 arguments.WriteRemoteObject(listener->AsObject());
140
141 SEND_REQUEST(BUFFER_PRODUCER_REGISTER_RELEASE_LISTENER, arguments, reply, option);
142 int32_t ret = reply.ReadInt32();
143 if (ret != GSERROR_OK) {
144 BLOGN_FAILURE("Remote return %{public}d", ret);
145 return (GSError)ret;
146 }
147 return GSERROR_OK;
148 }
149
GetQueueSize()150 uint32_t BufferClientProducer::GetQueueSize()
151 {
152 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
153
154 SEND_REQUEST(BUFFER_PRODUCER_GET_QUEUE_SIZE, arguments, reply, option);
155
156 return reply.ReadUint32();
157 }
158
SetQueueSize(uint32_t queueSize)159 GSError BufferClientProducer::SetQueueSize(uint32_t queueSize)
160 {
161 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
162
163 arguments.WriteInt32(queueSize);
164
165 SEND_REQUEST(BUFFER_PRODUCER_SET_QUEUE_SIZE, arguments, reply, option);
166 int32_t ret = reply.ReadInt32();
167 if (ret != GSERROR_OK) {
168 BLOGN_FAILURE("Remote return %{public}d", ret);
169 return (GSError)ret;
170 }
171
172 return GSERROR_OK;
173 }
174
GetName(std::string & name)175 GSError BufferClientProducer::GetName(std::string &name)
176 {
177 {
178 std::lock_guard<std::mutex> lockGuard(mutex_);
179 if (name_ != "not init") {
180 name = name_;
181 return GSERROR_OK;
182 }
183 }
184 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
185
186 SEND_REQUEST(BUFFER_PRODUCER_GET_NAME, arguments, reply, option);
187 int32_t ret = reply.ReadInt32();
188 if (ret != GSERROR_OK) {
189 BLOGN_FAILURE("Remote return %{public}d", ret);
190 return static_cast<GSError>(ret);
191 }
192 if (reply.ReadString(name) == false) {
193 BLOGN_FAILURE("reply.ReadString return false");
194 return GSERROR_BINDER;
195 }
196 {
197 std::lock_guard<std::mutex> lockGuard(mutex_);
198 name_ = name;
199 }
200 return static_cast<GSError>(ret);
201 }
202
GetUniqueId()203 uint64_t BufferClientProducer::GetUniqueId()
204 {
205 {
206 std::lock_guard<std::mutex> lockGuard(mutex_);
207 if (uniqueId_ != 0) {
208 return uniqueId_;
209 }
210 }
211 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
212 SEND_REQUEST(BUFFER_PRODUCER_GET_UNIQUE_ID, arguments, reply, option);
213 {
214 std::lock_guard<std::mutex> lockGuard(mutex_);
215 uniqueId_ = reply.ReadUint64();
216 }
217 return uniqueId_;
218 }
219
GetNameAndUniqueId(std::string & name,uint64_t & uniqueId)220 GSError BufferClientProducer::GetNameAndUniqueId(std::string& name, uint64_t& uniqueId)
221 {
222 {
223 std::lock_guard<std::mutex> lockGuard(mutex_);
224 if (uniqueId_ != 0 && name_ != "not init") {
225 uniqueId = uniqueId_;
226 name = name_;
227 return GSERROR_OK;
228 }
229 }
230 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
231
232 SEND_REQUEST(BUFFER_PRODUCER_GET_NAMEANDUNIQUEDID, arguments, reply, option);
233 int32_t ret = reply.ReadInt32();
234 if (ret != GSERROR_OK) {
235 BLOGN_FAILURE("Remote return %{public}d", ret);
236 return static_cast<GSError>(ret);
237 }
238 if (reply.ReadString(name) == false) {
239 BLOGN_FAILURE("reply.ReadString return false");
240 return GSERROR_BINDER;
241 }
242
243 uniqueId = reply.ReadUint64();
244 {
245 std::lock_guard<std::mutex> lockGuard(mutex_);
246 name_ = name;
247 uniqueId_ = uniqueId;
248 }
249 return static_cast<GSError>(ret);
250 }
251
GetDefaultWidth()252 int32_t BufferClientProducer::GetDefaultWidth()
253 {
254 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
255
256 SEND_REQUEST(BUFFER_PRODUCER_GET_DEFAULT_WIDTH, arguments, reply, option);
257
258 return reply.ReadInt32();
259 }
260
GetDefaultHeight()261 int32_t BufferClientProducer::GetDefaultHeight()
262 {
263 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
264
265 SEND_REQUEST(BUFFER_PRODUCER_GET_DEFAULT_HEIGHT, arguments, reply, option);
266
267 return reply.ReadInt32();
268 }
269
GetDefaultUsage()270 uint32_t BufferClientProducer::GetDefaultUsage()
271 {
272 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
273
274 SEND_REQUEST(BUFFER_PRODUCER_GET_DEFAULT_USAGE, arguments, reply, option);
275
276 return reply.ReadUint32();
277 }
278
CleanCache()279 GSError BufferClientProducer::CleanCache()
280 {
281 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
282
283 SEND_REQUEST(BUFFER_PRODUCER_CLEAN_CACHE, arguments, reply, option);
284 int32_t ret = reply.ReadInt32();
285 if (ret != GSERROR_OK) {
286 BLOGN_FAILURE("Remote return %{public}d", ret);
287 return (GSError)ret;
288 }
289
290 return GSERROR_OK;
291 }
292
GoBackground()293 GSError BufferClientProducer::GoBackground()
294 {
295 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
296
297 SEND_REQUEST(BUFFER_PRODUCER_GO_BACKGROUND, arguments, reply, option);
298 int32_t ret = reply.ReadInt32();
299 if (ret != GSERROR_OK) {
300 BLOGN_FAILURE("Remote return %{public}d", ret);
301 return (GSError)ret;
302 }
303
304 return GSERROR_OK;
305 }
306
SetTransform(GraphicTransformType transform)307 GSError BufferClientProducer::SetTransform(GraphicTransformType transform)
308 {
309 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
310
311 arguments.WriteUint32(static_cast<uint32_t>(transform));
312
313 SEND_REQUEST(BUFFER_PRODUCER_SET_TRANSFORM, arguments, reply, option);
314 int32_t ret = reply.ReadInt32();
315 if (ret != GSERROR_OK) {
316 BLOGN_FAILURE("Remote return %{public}d", ret);
317 return (GSError)ret;
318 }
319
320 return GSERROR_OK;
321 }
322
IsSupportedAlloc(const std::vector<BufferVerifyAllocInfo> & infos,std::vector<bool> & supporteds)323 GSError BufferClientProducer::IsSupportedAlloc(const std::vector<BufferVerifyAllocInfo> &infos,
324 std::vector<bool> &supporteds)
325 {
326 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
327
328 WriteVerifyAllocInfo(arguments, infos);
329
330 SEND_REQUEST(BUFFER_PRODUCER_IS_SUPPORTED_ALLOC, arguments, reply, option);
331 int32_t ret = reply.ReadInt32();
332 if (ret != GSERROR_OK) {
333 BLOGN_FAILURE("Remote return %{public}d", ret);
334 return static_cast<GSError>(ret);
335 }
336
337 if (reply.ReadBoolVector(&supporteds) == false) {
338 BLOGN_FAILURE("reply.ReadBoolVector return false");
339 return GSERROR_BINDER;
340 }
341
342 return static_cast<GSError>(ret);
343 }
344
Disconnect()345 GSError BufferClientProducer::Disconnect()
346 {
347 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
348
349 SEND_REQUEST(BUFFER_PRODUCER_DISCONNECT, arguments, reply, option);
350 int32_t ret = reply.ReadInt32();
351 if (ret != GSERROR_OK) {
352 BLOGN_FAILURE("Remote return %{public}d", ret);
353 return static_cast<GSError>(ret);
354 }
355 return GSERROR_OK;
356 }
357
SetScalingMode(uint32_t sequence,ScalingMode scalingMode)358 GSError BufferClientProducer::SetScalingMode(uint32_t sequence, ScalingMode scalingMode)
359 {
360 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
361 arguments.WriteUint32(sequence);
362 arguments.WriteInt32(static_cast<int32_t>(scalingMode));
363 SEND_REQUEST(BUFFER_PRODUCER_SET_SCALING_MODE, arguments, reply, option);
364 int32_t ret = reply.ReadInt32();
365 if (ret != GSERROR_OK) {
366 BLOGN_FAILURE("Remote return %{public}d", ret);
367 return (GSError)ret;
368 }
369
370 return GSERROR_OK;
371 }
372
SetMetaData(uint32_t sequence,const std::vector<GraphicHDRMetaData> & metaData)373 GSError BufferClientProducer::SetMetaData(uint32_t sequence, const std::vector<GraphicHDRMetaData> &metaData)
374 {
375 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
376 arguments.WriteUint32(sequence);
377 WriteHDRMetaData(arguments, metaData);
378 SEND_REQUEST(BUFFER_PRODUCER_SET_METADATA, arguments, reply, option);
379 int32_t ret = reply.ReadInt32();
380 if (ret != GSERROR_OK) {
381 BLOGN_FAILURE("Remote return %{public}d", ret);
382 return (GSError)ret;
383 }
384
385 return GSERROR_OK;
386 }
387
SetMetaDataSet(uint32_t sequence,GraphicHDRMetadataKey key,const std::vector<uint8_t> & metaData)388 GSError BufferClientProducer::SetMetaDataSet(uint32_t sequence, GraphicHDRMetadataKey key,
389 const std::vector<uint8_t> &metaData)
390 {
391 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
392 arguments.WriteUint32(sequence);
393 arguments.WriteUint32(static_cast<uint32_t>(key));
394 WriteHDRMetaDataSet(arguments, metaData);
395 SEND_REQUEST(BUFFER_PRODUCER_SET_METADATASET, arguments, reply, option);
396 int32_t ret = reply.ReadInt32();
397 if (ret != GSERROR_OK) {
398 BLOGN_FAILURE("Remote return %{public}d", ret);
399 return (GSError)ret;
400 }
401
402 return GSERROR_OK;
403 }
404
SetTunnelHandle(const GraphicExtDataHandle * handle)405 GSError BufferClientProducer::SetTunnelHandle(const GraphicExtDataHandle *handle)
406 {
407 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
408 if (handle == nullptr) {
409 arguments.WriteBool(false);
410 } else {
411 arguments.WriteBool(true);
412 WriteExtDataHandle(arguments, handle);
413 }
414 SEND_REQUEST(BUFFER_PRODUCER_SET_TUNNEL_HANDLE, arguments, reply, option);
415 int32_t ret = reply.ReadInt32();
416 if (ret != GSERROR_OK) {
417 BLOGN_FAILURE("Remote return %{public}d", ret);
418 return (GSError)ret;
419 }
420 return GSERROR_OK;
421 }
422
GetPresentTimestamp(uint32_t sequence,GraphicPresentTimestampType type,int64_t & time)423 GSError BufferClientProducer::GetPresentTimestamp(uint32_t sequence, GraphicPresentTimestampType type, int64_t &time)
424 {
425 DEFINE_MESSAGE_VARIABLES(arguments, reply, option, BLOGE);
426 arguments.WriteUint32(sequence);
427 arguments.WriteUint32(static_cast<uint32_t>(type));
428 SEND_REQUEST(BUFFER_PRODUCER_GET_PRESENT_TIMESTAMP, arguments, reply, option);
429 int32_t ret = reply.ReadInt32();
430 if (ret != GSERROR_OK) {
431 BLOGN_FAILURE("Remote return %{public}d", ret);
432 return static_cast<GSError>(ret);
433 }
434 time = reply.ReadInt64();
435 return static_cast<GSError>(ret);
436 }
437
GetNativeSurface()438 sptr<NativeSurface> BufferClientProducer::GetNativeSurface()
439 {
440 BLOGND("BufferClientProducer::GetNativeSurface not support.");
441 return nullptr;
442 }
443 }; // namespace OHOS
444