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 <cinttypes>
19
20#include <iremote_stub.h>
21#include "buffer_log.h"
22#include "buffer_utils.h"
23#include "hebc_white_list.h"
24#include "sync_fence.h"
25#include "message_option.h"
26#include "securec.h"
27#include "rs_frame_report_ext.h"
28
29#define DEFINE_MESSAGE_VARIABLES(arg, ret, opt)                            \
30    MessageOption opt;                                                     \
31    MessageParcel arg;                                                     \
32    MessageParcel ret;                                                     \
33    do {                                                                   \
34        GSError retCode = MessageVariables(arg);                           \
35        if (retCode != GSERROR_OK) {                                       \
36            return retCode;                                                \
37        }                                                                  \
38    } while (0)
39
40#define SEND_REQUEST(COMMAND, arguments, reply, option)                    \
41    do {                                                                   \
42        GSError ret = SendRequest(COMMAND, arguments, reply, option);      \
43        if (ret != GSERROR_OK) {                                           \
44            return ret;                                                    \
45        }                                                                  \
46    } while (0)
47
48namespace OHOS {
49namespace {
50    constexpr size_t MATRIX4_SIZE = 16;
51}
52BufferClientProducer::BufferClientProducer(const sptr<IRemoteObject>& impl)
53    : IRemoteProxy<IBufferProducer>(impl)
54{
55}
56
57BufferClientProducer::~BufferClientProducer()
58{
59}
60
61GSError BufferClientProducer::MessageVariables(MessageParcel &arg)
62{
63    if (!(arg).WriteInterfaceToken(GetDescriptor())) {
64        BLOGE("WriteInterfaceToken failed, uniqueId: %{public}" PRIu64 ".", uniqueId_);
65        return GSERROR_BINDER;
66    }
67    return GSERROR_OK;
68}
69
70GSError BufferClientProducer::SendRequest(uint32_t command, MessageParcel &arg,
71                                          MessageParcel &reply, MessageOption &opt)
72{
73    sptr<IRemoteObject> remote = Remote();
74    if (remote == nullptr) {
75        BLOGE("Remote is nullptr, uniqueId: %{public}" PRIu64 ".", uniqueId_);
76        return GSERROR_SERVER_ERROR;
77    }
78    int32_t ret = remote->SendRequest(command, arg, reply, opt);
79    if (ret != ERR_NONE) {
80        BLOGE("SendRequest ret: %{public}d, uniqueId: %{public}" PRIu64 ".", ret, uniqueId_);
81        return GSERROR_BINDER;
82    }
83    return GSERROR_OK;
84}
85
86GSError BufferClientProducer::CheckRetval(MessageParcel &reply)
87{
88    int32_t ret = reply.ReadInt32();
89    if (ret != GSERROR_OK) {
90        BLOGE("Remote ret: %{public}d, uniqueId: %{public}" PRIu64 ".", ret, uniqueId_);
91        return static_cast<GSError>(ret);
92    }
93    return GSERROR_OK;
94}
95
96GSError BufferClientProducer::RequestBuffer(const BufferRequestConfig &config, sptr<BufferExtraData> &bedata,
97                                            RequestBufferReturnValue &retval)
98{
99    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
100
101    GSError ret = WriteRequestConfig(arguments, config);
102    if (ret != GSERROR_OK) {
103        return ret;
104    }
105
106    retval.isConnected = false;
107    SEND_REQUEST(BUFFER_PRODUCER_REQUEST_BUFFER, arguments, reply, option);
108    ret = CheckRetval(reply);
109    if (ret != GSERROR_OK) {
110        reply.ReadBool(retval.isConnected);
111        return ret;
112    }
113
114    ret = ReadSurfaceBufferImpl(reply, retval.sequence, retval.buffer);
115    if (ret != GSERROR_OK) {
116        return SURFACE_ERROR_UNKOWN;
117    }
118    if (retval.buffer != nullptr) {
119        retval.buffer->SetBufferRequestConfig(config);
120    }
121
122    ret = bedata->ReadFromParcel(reply);
123    if (ret != GSERROR_OK) {
124        return SURFACE_ERROR_UNKOWN;
125    }
126    retval.fence = SyncFence::ReadFromMessageParcel(reply);
127    if (!reply.ReadUInt32Vector(&retval.deletingBuffers)) {
128        return GSERROR_BINDER;
129    }
130
131    return GSERROR_OK;
132}
133
134GSError BufferClientProducer::RequestBuffers(const BufferRequestConfig &config,
135    std::vector<sptr<BufferExtraData>> &bedata, std::vector<RequestBufferReturnValue> &retvalues)
136{
137    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
138
139    uint32_t num = static_cast<uint32_t>(bedata.size());
140    if (!arguments.WriteUint32(num)) {
141        return GSERROR_BINDER;
142    }
143    GSError ret = WriteRequestConfig(arguments, config);
144    if (ret != GSERROR_OK) {
145        return ret;
146    }
147    retvalues[0].isConnected = false;
148    SEND_REQUEST(BUFFER_PRODUCER_REQUEST_BUFFERS, arguments, reply, option);
149    ret = CheckRetval(reply);
150    if (ret != GSERROR_OK && ret != GSERROR_NO_BUFFER) {
151        reply.ReadBool(retvalues[0].isConnected);
152        return ret;
153    }
154
155    num = reply.ReadUint32();
156    if (num > SURFACE_MAX_QUEUE_SIZE || num == 0) {
157        BLOGE("num is invalid, %{public}u, uniqueId: %{public}" PRIu64 ".", num, uniqueId_);
158        return SURFACE_ERROR_UNKOWN;
159    }
160
161    ret = GSERROR_OK;
162    retvalues.resize(num);
163    for (size_t i = 0; i < num; ++i) {
164        auto &retval = retvalues[i];
165        ret = ReadSurfaceBufferImpl(reply, retval.sequence, retval.buffer);
166        if (ret != GSERROR_OK) {
167            return SURFACE_ERROR_UNKOWN;
168        }
169        if (retval.buffer != nullptr) {
170            retval.buffer->SetBufferRequestConfig(config);
171        }
172        ret = bedata[i]->ReadFromParcel(reply);
173        if (ret != GSERROR_OK) {
174            return SURFACE_ERROR_UNKOWN;
175        }
176        retval.fence = SyncFence::ReadFromMessageParcel(reply);
177        if (!reply.ReadUInt32Vector(&retval.deletingBuffers)) {
178            return GSERROR_BINDER;
179        }
180    }
181    return ret;
182}
183
184GSError BufferClientProducer::GetLastFlushedBufferCommon(sptr<SurfaceBuffer>& buffer,
185    sptr<SyncFence>& fence, float matrix[16], uint32_t matrixSize, bool isUseNewMatrix, uint32_t command)
186{
187    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
188    if (!arguments.WriteBool(isUseNewMatrix)) {
189        return GSERROR_BINDER;
190    }
191    SEND_REQUEST(command, arguments, reply, option);
192    GSError ret = CheckRetval(reply);
193    if (ret != GSERROR_OK) {
194        return ret;
195    }
196    uint32_t sequence;
197    ret = ReadSurfaceBufferImpl(reply, sequence, buffer);
198    if (ret != GSERROR_OK) {
199        return SURFACE_ERROR_UNKOWN;
200    }
201    if (buffer == nullptr) {
202        return SURFACE_ERROR_NULLPTR;
203    }
204    ret = buffer->ReadBufferRequestConfig(reply);
205    if (ret != GSERROR_OK) {
206        return SURFACE_ERROR_UNKOWN;
207    }
208
209    fence = SyncFence::ReadFromMessageParcel(reply);
210    std::vector<float> readMatrixVector;
211    if (!reply.ReadFloatVector(&readMatrixVector)) {
212        return GSERROR_BINDER;
213    }
214    if (readMatrixVector.size() != MATRIX4_SIZE) {
215        return GSERROR_INVALID_ARGUMENTS;
216    }
217    if (memcpy_s(matrix, matrixSize * sizeof(float),
218        readMatrixVector.data(), readMatrixVector.size() * sizeof(float)) != EOK) {
219        BLOGE("memcpy_s fail, uniqueId: %{public}" PRIu64 ".", uniqueId_);
220        return SURFACE_ERROR_UNKOWN;
221    }
222    return GSERROR_OK;
223}
224
225GSError BufferClientProducer::GetLastFlushedBuffer(sptr<SurfaceBuffer>& buffer,
226    sptr<SyncFence>& fence, float matrix[16], bool isUseNewMatrix)
227{
228    return GetLastFlushedBufferCommon(buffer, fence,
229        matrix, MATRIX4_SIZE, isUseNewMatrix, BUFFER_PRODUCER_GET_LAST_FLUSHED_BUFFER);
230}
231
232GSError BufferClientProducer::GetProducerInitInfo(ProducerInitInfo &info)
233{
234    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
235    token_ = new IRemoteStub<IBufferProducerToken>();
236    HebcWhiteList::GetInstance().GetApplicationName(info.appName);
237    if (!arguments.WriteRemoteObject(token_->AsObject()) || !arguments.WriteString(info.appName)) {
238        return GSERROR_BINDER;
239    }
240    SEND_REQUEST(BUFFER_PRODUCER_GET_INIT_INFO, arguments, reply, option);
241    if (!reply.ReadInt32(info.width) || !reply.ReadInt32(info.height) ||
242        !reply.ReadUint64(info.uniqueId)) {
243        return GSERROR_BINDER;
244    }
245    uniqueId_ = info.uniqueId;
246    if (!reply.ReadString(info.name) || !reply.ReadBool(info.isInHebcList)) {
247        return GSERROR_BINDER;
248    }
249    return CheckRetval(reply);
250}
251
252GSError BufferClientProducer::CancelBuffer(uint32_t sequence, sptr<BufferExtraData> bedata)
253{
254    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
255
256    if (!arguments.WriteUint32(sequence)) {
257        return GSERROR_BINDER;
258    }
259    GSError ret = bedata->WriteToParcel(arguments);
260    if (ret != GSERROR_OK) {
261        return GSERROR_BINDER;
262    }
263
264    SEND_REQUEST(BUFFER_PRODUCER_CANCEL_BUFFER, arguments, reply, option);
265    return CheckRetval(reply);
266}
267
268GSError BufferClientProducer::FlushBuffer(uint32_t sequence, sptr<BufferExtraData> bedata,
269                                          sptr<SyncFence> fence, BufferFlushConfigWithDamages &config)
270{
271    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
272
273    if (!arguments.WriteUint32(sequence)) {
274        return GSERROR_BINDER;
275    }
276    GSError ret = bedata->WriteToParcel(arguments);
277    if (ret != GSERROR_OK) {
278        return ret;
279    }
280    if (!fence->WriteToMessageParcel(arguments)) {
281        return GSERROR_BINDER;
282    }
283    ret = WriteFlushConfig(arguments, config);
284    if (ret != GSERROR_OK) {
285        return ret;
286    }
287
288    SEND_REQUEST(BUFFER_PRODUCER_FLUSH_BUFFER, arguments, reply, option);
289    ret = CheckRetval(reply);
290    if (ret != GSERROR_OK) {
291        return ret;
292    }
293
294    if (OHOS::RsFrameReportExt::GetInstance().GetEnable()) {
295        OHOS::RsFrameReportExt::GetInstance().HandleSwapBuffer();
296    }
297    return GSERROR_OK;
298}
299
300GSError BufferClientProducer::FlushBuffers(const std::vector<uint32_t> &sequences,
301    const std::vector<sptr<BufferExtraData>> &bedata,
302    const std::vector<sptr<SyncFence>> &fences,
303    const std::vector<BufferFlushConfigWithDamages> &configs)
304{
305    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
306
307    if (sequences.empty() || sequences.size() > SURFACE_MAX_QUEUE_SIZE) {
308        return SURFACE_ERROR_UNKOWN;
309    }
310    if (!arguments.WriteUInt32Vector(sequences)) {
311        return GSERROR_BINDER;
312    }
313    GSError ret = GSERROR_OK;
314    for (uint32_t i = 0; i < sequences.size(); ++i) {
315        ret = bedata[i]->WriteToParcel(arguments);
316        if (ret != GSERROR_OK) {
317            return ret;
318        }
319        if (!fences[i]->WriteToMessageParcel(arguments)) {
320            return GSERROR_BINDER;
321        }
322        ret = WriteFlushConfig(arguments, configs[i]);
323        if (ret != GSERROR_OK) {
324            return ret;
325        }
326    }
327    SEND_REQUEST(BUFFER_PRODUCER_FLUSH_BUFFERS, arguments, reply, option);
328    return CheckRetval(reply);
329}
330
331GSError BufferClientProducer::AttachBufferToQueue(sptr<SurfaceBuffer> buffer)
332{
333    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
334    uint32_t sequence = buffer->GetSeqNum();
335    GSError ret = WriteSurfaceBufferImpl(arguments, sequence, buffer);
336    if (ret != GSERROR_OK) {
337        return ret;
338    }
339    ret = buffer->WriteBufferRequestConfig(arguments);
340    if (ret != GSERROR_OK) {
341        BLOGE("WriteBufferRequestConfig ret: %{public}d, uniqueId: %{public}" PRIu64 ".", ret, uniqueId_);
342        return ret;
343    }
344    SEND_REQUEST(BUFFER_PRODUCER_ATTACH_BUFFER_TO_QUEUE, arguments, reply, option);
345    return CheckRetval(reply);
346}
347
348GSError BufferClientProducer::DetachBufferFromQueue(sptr<SurfaceBuffer> buffer)
349{
350    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
351    uint32_t sequence = buffer->GetSeqNum();
352    GSError ret = WriteSurfaceBufferImpl(arguments, sequence, buffer);
353    if (ret != GSERROR_OK) {
354        return ret;
355    }
356    SEND_REQUEST(BUFFER_PRODUCER_DETACH_BUFFER_FROM_QUEUE, arguments, reply, option);
357    return CheckRetval(reply);
358}
359
360GSError BufferClientProducer::AttachBuffer(sptr<SurfaceBuffer>& buffer)
361{
362    return GSERROR_NOT_SUPPORT;
363}
364
365GSError BufferClientProducer::AttachBuffer(sptr<SurfaceBuffer>& buffer, int32_t timeOut)
366{
367    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
368    uint32_t sequence = buffer->GetSeqNum();
369    GSError ret = WriteSurfaceBufferImpl(arguments, sequence, buffer);
370    if (ret != GSERROR_OK) {
371        return ret;
372    }
373    if (!arguments.WriteInt32(timeOut)) {
374        return GSERROR_BINDER;
375    }
376    SEND_REQUEST(BUFFER_PRODUCER_ATTACH_BUFFER, arguments, reply, option);
377    return CheckRetval(reply);
378}
379
380GSError BufferClientProducer::DetachBuffer(sptr<SurfaceBuffer>& buffer)
381{
382    return GSERROR_NOT_SUPPORT;
383}
384
385GSError BufferClientProducer::RegisterReleaseListener(sptr<IProducerListener> listener)
386{
387    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
388
389    if (!arguments.WriteRemoteObject(listener->AsObject())) {
390        return GSERROR_BINDER;
391    }
392
393    SEND_REQUEST(BUFFER_PRODUCER_REGISTER_RELEASE_LISTENER, arguments, reply, option);
394    return CheckRetval(reply);
395}
396
397GSError BufferClientProducer::UnRegisterReleaseListener()
398{
399    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
400    SEND_REQUEST(BUFFER_PRODUCER_UNREGISTER_RELEASE_LISTENER, arguments, reply, option);
401    return CheckRetval(reply);
402}
403
404uint32_t BufferClientProducer::GetQueueSize()
405{
406    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
407
408    SEND_REQUEST(BUFFER_PRODUCER_GET_QUEUE_SIZE, arguments, reply, option);
409
410    return reply.ReadUint32();
411}
412
413GSError BufferClientProducer::SetQueueSize(uint32_t queueSize)
414{
415    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
416
417    if (!arguments.WriteUint32(queueSize)) {
418        return GSERROR_BINDER;
419    }
420
421    SEND_REQUEST(BUFFER_PRODUCER_SET_QUEUE_SIZE, arguments, reply, option);
422    return CheckRetval(reply);
423}
424
425GSError BufferClientProducer::GetName(std::string &name)
426{
427    {
428        std::lock_guard<std::mutex> lockGuard(mutex_);
429        if (name_ != DEFAULT_NAME) {
430            name = name_;
431            return GSERROR_OK;
432        }
433    }
434    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
435
436    SEND_REQUEST(BUFFER_PRODUCER_GET_NAME, arguments, reply, option);
437    GSError ret = CheckRetval(reply);
438    if (ret != GSERROR_OK) {
439        return ret;
440    }
441    if (!reply.ReadString(name)) {
442        BLOGE("reply.ReadString return false, uniqueId: %{public}" PRIu64 ".", uniqueId_);
443        return GSERROR_BINDER;
444    }
445    {
446        std::lock_guard<std::mutex> lockGuard(mutex_);
447        name_ = name;
448    }
449    return ret;
450}
451
452uint64_t BufferClientProducer::GetUniqueId()
453{
454    {
455        std::lock_guard<std::mutex> lockGuard(mutex_);
456        if (uniqueId_ != 0) {
457            return uniqueId_;
458        }
459    }
460    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
461    SEND_REQUEST(BUFFER_PRODUCER_GET_UNIQUE_ID, arguments, reply, option);
462    {
463        std::lock_guard<std::mutex> lockGuard(mutex_);
464        uniqueId_ = reply.ReadUint64();
465        return uniqueId_;
466    }
467}
468
469GSError BufferClientProducer::GetNameAndUniqueId(std::string& name, uint64_t& uniqueId)
470{
471    {
472        std::lock_guard<std::mutex> lockGuard(mutex_);
473        if (uniqueId_ != 0 && name_ != DEFAULT_NAME) {
474            uniqueId = uniqueId_;
475            name = name_;
476            return GSERROR_OK;
477        }
478    }
479    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
480
481    SEND_REQUEST(BUFFER_PRODUCER_GET_NAMEANDUNIQUEDID, arguments, reply, option);
482    GSError ret = CheckRetval(reply);
483    if (ret != GSERROR_OK) {
484        return ret;
485    }
486    if (!reply.ReadString(name)) {
487        BLOGE("reply.ReadString return false, uniqueId: %{public}" PRIu64 ".", uniqueId_);
488        return GSERROR_BINDER;
489    }
490
491    uniqueId = reply.ReadUint64();
492    {
493        std::lock_guard<std::mutex> lockGuard(mutex_);
494        name_ = name;
495        uniqueId_ = uniqueId;
496    }
497    return ret;
498}
499
500int32_t BufferClientProducer::GetDefaultWidth()
501{
502    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
503
504    SEND_REQUEST(BUFFER_PRODUCER_GET_DEFAULT_WIDTH, arguments, reply, option);
505
506    return reply.ReadInt32();
507}
508
509int32_t BufferClientProducer::GetDefaultHeight()
510{
511    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
512
513    SEND_REQUEST(BUFFER_PRODUCER_GET_DEFAULT_HEIGHT, arguments, reply, option);
514
515    return reply.ReadInt32();
516}
517
518GSError BufferClientProducer::SetDefaultUsage(uint64_t usage)
519{
520    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
521
522    if (!arguments.WriteUint64(usage)) {
523        return GSERROR_BINDER;
524    }
525
526    SEND_REQUEST(BUFFER_PRODUCER_SET_DEFAULT_USAGE, arguments, reply, option);
527
528    return CheckRetval(reply);
529}
530
531uint64_t BufferClientProducer::GetDefaultUsage()
532{
533    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
534
535    SEND_REQUEST(BUFFER_PRODUCER_GET_DEFAULT_USAGE, arguments, reply, option);
536
537    return reply.ReadUint64();
538}
539
540GSError BufferClientProducer::CleanCache(bool cleanAll)
541{
542    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
543
544    if (!arguments.WriteBool(cleanAll)) {
545        return GSERROR_BINDER;
546    }
547    SEND_REQUEST(BUFFER_PRODUCER_CLEAN_CACHE, arguments, reply, option);
548    return CheckRetval(reply);
549}
550
551GSError BufferClientProducer::GoBackground()
552{
553    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
554
555    SEND_REQUEST(BUFFER_PRODUCER_GO_BACKGROUND, arguments, reply, option);
556    return CheckRetval(reply);
557}
558
559GSError BufferClientProducer::SetTransform(GraphicTransformType transform)
560{
561    {
562        std::lock_guard<std::mutex> lockGuard(mutex_);
563        if (lastSetTransformType_ == transform) {
564            return GSERROR_OK;
565        }
566        lastSetTransformType_ = transform;
567    }
568
569    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
570
571    if (!arguments.WriteUint32(static_cast<uint32_t>(transform))) {
572        return GSERROR_BINDER;
573    }
574
575    SEND_REQUEST(BUFFER_PRODUCER_SET_TRANSFORM, arguments, reply, option);
576    GSError ret = CheckRetval(reply);
577    if (ret != GSERROR_OK) {
578        {
579            std::lock_guard<std::mutex> lockGuard(mutex_);
580            lastSetTransformType_ = GraphicTransformType::GRAPHIC_ROTATE_BUTT;
581        }
582        return ret;
583    }
584
585    return GSERROR_OK;
586}
587
588GSError BufferClientProducer::IsSupportedAlloc(const std::vector<BufferVerifyAllocInfo> &infos,
589                                               std::vector<bool> &supporteds)
590{
591    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
592
593    GSError ret = WriteVerifyAllocInfo(arguments, infos);
594    if (ret != GSERROR_OK) {
595        return ret;
596    }
597
598    SEND_REQUEST(BUFFER_PRODUCER_IS_SUPPORTED_ALLOC, arguments, reply, option);
599    ret = CheckRetval(reply);
600    if (ret != GSERROR_OK) {
601        return ret;
602    }
603
604    if (!reply.ReadBoolVector(&supporteds)) {
605        BLOGE("reply.ReadBoolVector return false, uniqueId: %{public}" PRIu64 ".", uniqueId_);
606        return GSERROR_BINDER;
607    }
608
609    return static_cast<GSError>(ret);
610}
611
612GSError BufferClientProducer::Connect()
613{
614    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
615
616    SEND_REQUEST(BUFFER_PRODUCER_CONNECT, arguments, reply, option);
617    return CheckRetval(reply);
618}
619
620GSError BufferClientProducer::Disconnect()
621{
622    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
623
624    SEND_REQUEST(BUFFER_PRODUCER_DISCONNECT, arguments, reply, option);
625    return CheckRetval(reply);
626}
627
628GSError BufferClientProducer::SetScalingMode(uint32_t sequence, ScalingMode scalingMode)
629{
630    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
631    if (!arguments.WriteUint32(sequence) || !arguments.WriteInt32(static_cast<int32_t>(scalingMode))) {
632        return GSERROR_BINDER;
633    }
634    SEND_REQUEST(BUFFER_PRODUCER_SET_SCALING_MODE, arguments, reply, option);
635    return CheckRetval(reply);
636}
637
638GSError BufferClientProducer::SetScalingMode(ScalingMode scalingMode)
639{
640    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
641    if (!arguments.WriteInt32(static_cast<int32_t>(scalingMode))) {
642        return GSERROR_BINDER;
643    }
644    SEND_REQUEST(BUFFER_PRODUCER_SET_SCALING_MODEV2, arguments, reply, option);
645    return CheckRetval(reply);
646}
647
648GSError BufferClientProducer::SetBufferHold(bool hold)
649{
650    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
651    if (!arguments.WriteBool(hold)) {
652        return GSERROR_BINDER;
653    }
654    SEND_REQUEST(BUFFER_PRODUCER_SET_BUFFER_HOLD, arguments, reply, option);
655    return CheckRetval(reply);
656}
657
658GSError BufferClientProducer::SetMetaData(uint32_t sequence, const std::vector<GraphicHDRMetaData> &metaData)
659{
660    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
661    if (!arguments.WriteUint32(sequence)) {
662        return GSERROR_BINDER;
663    }
664    GSError ret = WriteHDRMetaData(arguments, metaData);
665    if (ret != GSERROR_OK) {
666        return ret;
667    }
668    SEND_REQUEST(BUFFER_PRODUCER_SET_METADATA, arguments, reply, option);
669    return CheckRetval(reply);
670}
671
672GSError BufferClientProducer::SetMetaDataSet(uint32_t sequence, GraphicHDRMetadataKey key,
673                                             const std::vector<uint8_t> &metaData)
674{
675    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
676    if (!arguments.WriteUint32(sequence) || !arguments.WriteUint32(static_cast<uint32_t>(key))) {
677        return GSERROR_BINDER;
678    }
679    GSError ret = WriteHDRMetaDataSet(arguments, metaData);
680    if (ret != GSERROR_OK) {
681        return ret;
682    }
683    SEND_REQUEST(BUFFER_PRODUCER_SET_METADATASET, arguments, reply, option);
684    return CheckRetval(reply);
685}
686
687GSError BufferClientProducer::SetTunnelHandle(const GraphicExtDataHandle *handle)
688{
689    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
690    if (handle == nullptr) {
691        if (!arguments.WriteBool(false)) {
692            return GSERROR_BINDER;
693        }
694    } else {
695        if (!arguments.WriteBool(true)) {
696            return GSERROR_BINDER;
697        }
698        GSError ret = WriteExtDataHandle(arguments, handle);
699        if (ret != GSERROR_OK) {
700            return ret;
701        }
702    }
703    SEND_REQUEST(BUFFER_PRODUCER_SET_TUNNEL_HANDLE, arguments, reply, option);
704    return CheckRetval(reply);
705}
706
707GSError BufferClientProducer::GetPresentTimestamp(uint32_t sequence, GraphicPresentTimestampType type, int64_t &time)
708{
709    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
710    if (!arguments.WriteUint32(sequence) || !arguments.WriteUint32(static_cast<uint32_t>(type))) {
711        return GSERROR_BINDER;
712    }
713    SEND_REQUEST(BUFFER_PRODUCER_GET_PRESENT_TIMESTAMP, arguments, reply, option);
714    GSError ret = CheckRetval(reply);
715    if (ret != GSERROR_OK) {
716        return ret;
717    }
718    time = reply.ReadInt64();
719    return static_cast<GSError>(ret);
720}
721
722sptr<NativeSurface> BufferClientProducer::GetNativeSurface()
723{
724    return nullptr;
725}
726
727GSError BufferClientProducer::GetTransform(GraphicTransformType &transform)
728{
729    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
730    SEND_REQUEST(BUFFER_PRODUCER_GET_TRANSFORM, arguments, reply, option);
731
732    GSError ret = CheckRetval(reply);
733    if (ret != GSERROR_OK) {
734        return ret;
735    }
736    transform = static_cast<GraphicTransformType>(reply.ReadUint32());
737    return GSERROR_OK;
738}
739
740GSError BufferClientProducer::GetTransformHint(GraphicTransformType &transformHint)
741{
742    return GSERROR_NOT_SUPPORT;
743}
744
745GSError BufferClientProducer::SetTransformHint(GraphicTransformType transformHint)
746{
747    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
748
749    if (!arguments.WriteUint32(static_cast<uint32_t>(transformHint))) {
750        return GSERROR_BINDER;
751    }
752
753    SEND_REQUEST(BUFFER_PRODUCER_SET_TRANSFORMHINT, arguments, reply, option);
754    return CheckRetval(reply);
755}
756
757GSError BufferClientProducer::SetSurfaceSourceType(OHSurfaceSource sourceType)
758{
759    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
760    if (!arguments.WriteUint32(static_cast<uint32_t>(sourceType))) {
761        return GSERROR_BINDER;
762    }
763    SEND_REQUEST(BUFFER_PRODUCER_SET_SOURCE_TYPE, arguments, reply, option);
764    return CheckRetval(reply);
765}
766
767GSError BufferClientProducer::GetSurfaceSourceType(OHSurfaceSource &sourceType)
768{
769    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
770    SEND_REQUEST(BUFFER_PRODUCER_GET_SOURCE_TYPE, arguments, reply, option);
771    GSError ret = CheckRetval(reply);
772    if (ret != GSERROR_OK) {
773        return ret;
774    }
775    sourceType = static_cast<OHSurfaceSource>(reply.ReadUint32());
776    return GSERROR_OK;
777}
778
779GSError BufferClientProducer::SetSurfaceAppFrameworkType(std::string appFrameworkType)
780{
781    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
782    if (!arguments.WriteString(appFrameworkType)) {
783        return GSERROR_BINDER;
784    }
785    SEND_REQUEST(BUFFER_PRODUCER_SET_APP_FRAMEWORK_TYPE, arguments, reply, option);
786    return CheckRetval(reply);
787}
788
789GSError BufferClientProducer::GetSurfaceAppFrameworkType(std::string &appFrameworkType)
790{
791    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
792    SEND_REQUEST(BUFFER_PRODUCER_GET_APP_FRAMEWORK_TYPE, arguments, reply, option);
793    GSError ret = CheckRetval(reply);
794    if (ret != GSERROR_OK) {
795        return ret;
796    }
797    appFrameworkType = static_cast<std::string>(reply.ReadString());
798    return GSERROR_OK;
799}
800
801GSError BufferClientProducer::SetHdrWhitePointBrightness(float brightness)
802{
803    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
804
805    if (!arguments.WriteFloat(brightness)) {
806        return GSERROR_BINDER;
807    }
808
809    SEND_REQUEST(BUFFER_PRODUCER_SET_HDRWHITEPOINTBRIGHTNESS, arguments, reply, option);
810    return CheckRetval(reply);
811}
812
813GSError BufferClientProducer::SetSdrWhitePointBrightness(float brightness)
814{
815    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
816
817    if (!arguments.WriteFloat(brightness)) {
818        return GSERROR_BINDER;
819    }
820
821    SEND_REQUEST(BUFFER_PRODUCER_SET_SDRWHITEPOINTBRIGHTNESS, arguments, reply, option);
822    return CheckRetval(reply);
823}
824
825GSError BufferClientProducer::AcquireLastFlushedBuffer(sptr<SurfaceBuffer> &buffer, sptr<SyncFence> &fence,
826    float matrix[16], uint32_t matrixSize, bool isUseNewMatrix)
827{
828    return GetLastFlushedBufferCommon(buffer, fence,
829        matrix, matrixSize, isUseNewMatrix, BUFFER_PRODUCER_ACQUIRE_LAST_FLUSHED_BUFFER);
830}
831
832GSError BufferClientProducer::ReleaseLastFlushedBuffer(uint32_t sequence)
833{
834    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
835    if (!arguments.WriteUint32(sequence)) {
836        return GSERROR_BINDER;
837    }
838    SEND_REQUEST(BUFFER_PRODUCER_RELEASE_LAST_FLUSHED_BUFFER, arguments, reply, option);
839    return CheckRetval(reply);
840}
841
842GSError BufferClientProducer::SetGlobalAlpha(int32_t alpha)
843{
844    DEFINE_MESSAGE_VARIABLES(arguments, reply, option);
845    if (!arguments.WriteInt32(alpha)) {
846        return GSERROR_BINDER;
847    }
848    SEND_REQUEST(BUFFER_PRODUCER_SET_GLOBALALPHA, arguments, reply, option);
849    return CheckRetval(reply);
850}
851}; // namespace OHOS
852