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