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