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_queue_producer.h"
17
18#include <cinttypes>
19#include <mutex>
20#include <set>
21
22#include "buffer_extra_data_impl.h"
23#include "buffer_log.h"
24#include "buffer_producer_listener.h"
25#include "buffer_utils.h"
26#include "frame_report.h"
27#include "sync_fence.h"
28
29#define BUFFER_PRODUCER_API_FUNC_PAIR(apiSequenceNum, func) \
30    {apiSequenceNum, [](BufferQueueProducer *that, MessageParcel &arguments, MessageParcel &reply, \
31        MessageOption &option){return that->func(arguments, reply, option);}} \
32
33namespace OHOS {
34namespace {
35constexpr int32_t BUFFER_MATRIX_SIZE = 16;
36} // namespace
37
38BufferQueueProducer::BufferQueueProducer(sptr<BufferQueue> bufferQueue)
39    : producerSurfaceDeathRecipient_(new ProducerSurfaceDeathRecipient(this))
40{
41    bufferQueue_ = std::move(bufferQueue);
42    if (bufferQueue_ != nullptr) {
43        bufferQueue_->GetName(name_);
44        uniqueId_ = bufferQueue_->GetUniqueId();
45    }
46    memberFuncMap_ = {
47        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GET_INIT_INFO, GetProducerInitInfoRemote),
48        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_REQUEST_BUFFER, RequestBufferRemote),
49        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_REQUEST_BUFFERS, RequestBuffersRemote),
50        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_CANCEL_BUFFER, CancelBufferRemote),
51        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_FLUSH_BUFFER, FlushBufferRemote),
52        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_FLUSH_BUFFERS, FlushBuffersRemote),
53        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_ATTACH_BUFFER, AttachBufferRemote),
54        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_DETACH_BUFFER, DetachBufferRemote),
55        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GET_QUEUE_SIZE, GetQueueSizeRemote),
56        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_SET_QUEUE_SIZE, SetQueueSizeRemote),
57        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GET_NAME, GetNameRemote),
58        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GET_DEFAULT_WIDTH, GetDefaultWidthRemote),
59        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GET_DEFAULT_HEIGHT, GetDefaultHeightRemote),
60        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GET_DEFAULT_USAGE, GetDefaultUsageRemote),
61        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GET_UNIQUE_ID, GetUniqueIdRemote),
62        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_CLEAN_CACHE, CleanCacheRemote),
63        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_REGISTER_RELEASE_LISTENER, RegisterReleaseListenerRemote),
64        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_SET_TRANSFORM, SetTransformRemote),
65        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_IS_SUPPORTED_ALLOC, IsSupportedAllocRemote),
66        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GET_NAMEANDUNIQUEDID, GetNameAndUniqueIdRemote),
67        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_DISCONNECT, DisconnectRemote),
68        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_CONNECT, ConnectRemote),
69        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_SET_SCALING_MODE, SetScalingModeRemote),
70        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_SET_METADATA, SetMetaDataRemote),
71        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_SET_METADATASET, SetMetaDataSetRemote),
72        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_SET_TUNNEL_HANDLE, SetTunnelHandleRemote),
73        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GO_BACKGROUND, GoBackgroundRemote),
74        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GET_PRESENT_TIMESTAMP, GetPresentTimestampRemote),
75        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_UNREGISTER_RELEASE_LISTENER, UnRegisterReleaseListenerRemote),
76        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GET_LAST_FLUSHED_BUFFER, GetLastFlushedBufferRemote),
77        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GET_TRANSFORM, GetTransformRemote),
78        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_ATTACH_BUFFER_TO_QUEUE, AttachBufferToQueueRemote),
79        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_DETACH_BUFFER_FROM_QUEUE, DetachBufferFromQueueRemote),
80        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_SET_DEFAULT_USAGE, SetDefaultUsageRemote),
81        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GET_TRANSFORMHINT, GetTransformHintRemote),
82        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_SET_TRANSFORMHINT, SetTransformHintRemote),
83        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_SET_BUFFER_HOLD, SetBufferHoldRemote),
84        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_SET_SCALING_MODEV2, SetScalingModeV2Remote),
85        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_SET_SOURCE_TYPE, SetSurfaceSourceTypeRemote),
86        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GET_SOURCE_TYPE, GetSurfaceSourceTypeRemote),
87        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_SET_APP_FRAMEWORK_TYPE, SetSurfaceAppFrameworkTypeRemote),
88        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_GET_APP_FRAMEWORK_TYPE, GetSurfaceAppFrameworkTypeRemote),
89        BUFFER_PRODUCER_API_FUNC_PAIR(
90            BUFFER_PRODUCER_SET_HDRWHITEPOINTBRIGHTNESS, SetHdrWhitePointBrightnessRemote),
91        BUFFER_PRODUCER_API_FUNC_PAIR(
92            BUFFER_PRODUCER_SET_SDRWHITEPOINTBRIGHTNESS, SetSdrWhitePointBrightnessRemote),
93        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_ACQUIRE_LAST_FLUSHED_BUFFER, AcquireLastFlushedBufferRemote),
94        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_RELEASE_LAST_FLUSHED_BUFFER, ReleaseLastFlushedBufferRemote),
95        BUFFER_PRODUCER_API_FUNC_PAIR(BUFFER_PRODUCER_SET_GLOBALALPHA, SetGlobalAlphaRemote),
96    };
97}
98
99BufferQueueProducer::~BufferQueueProducer()
100{
101    if (token_ && producerSurfaceDeathRecipient_) {
102        token_->RemoveDeathRecipient(producerSurfaceDeathRecipient_);
103        token_ = nullptr;
104    }
105}
106
107GSError BufferQueueProducer::CheckConnectLocked()
108{
109    if (connectedPid_ == 0) {
110        BLOGW("no connections, uniqueId: %{public}" PRIu64 ".", uniqueId_);
111        return SURFACE_ERROR_CONSUMER_DISCONNECTED;
112    }
113
114    if (connectedPid_ != GetCallingPid()) {
115        BLOGW("connected by: %{public}d, uniqueId: %{public}" PRIu64 ".", connectedPid_, uniqueId_);
116        return SURFACE_ERROR_CONSUMER_IS_CONNECTED;
117    }
118
119    return GSERROR_OK;
120}
121
122int32_t BufferQueueProducer::OnRemoteRequest(uint32_t code, MessageParcel &arguments,
123                                             MessageParcel &reply, MessageOption &option)
124{
125    auto it = memberFuncMap_.find(code);
126    if (it == memberFuncMap_.end()) {
127        BLOGE("cannot process %{public}u", code);
128        return IPCObjectStub::OnRemoteRequest(code, arguments, reply, option);
129    }
130
131    if (it->second == nullptr) {
132        BLOGE("memberFuncMap_[%{public}u] is nullptr", code);
133        return ERR_NONE;
134    }
135
136    auto remoteDescriptor = arguments.ReadInterfaceToken();
137    if (GetDescriptor() != remoteDescriptor) {
138        return ERR_INVALID_STATE;
139    }
140
141    auto ret = it->second(this, arguments, reply, option);
142    return ret;
143}
144
145int32_t BufferQueueProducer::RequestBufferRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
146{
147    RequestBufferReturnValue retval;
148    sptr<BufferExtraData> bedataimpl = new BufferExtraDataImpl;
149    BufferRequestConfig config = {};
150    int64_t startTimeNs = 0;
151    int64_t endTimeNs = 0;
152    bool isActiveGame = false;
153    int32_t connectedPid = 0;
154    {
155        std::lock_guard<std::mutex> lock(mutex_);
156        connectedPid = connectedPid_;
157    }
158    isActiveGame = Rosen::FrameReport::GetInstance().IsActiveGameWithPid(connectedPid);
159    if (isActiveGame) {
160        startTimeNs = std::chrono::duration_cast<std::chrono::nanoseconds>(
161            std::chrono::steady_clock::now().time_since_epoch()).count();
162    }
163
164    ReadRequestConfig(arguments, config);
165
166    GSError sRet = RequestBuffer(config, bedataimpl, retval);
167    if (!reply.WriteInt32(sRet)) {
168        return IPC_STUB_WRITE_PARCEL_ERR;
169    }
170    if (sRet == GSERROR_OK &&
171        (WriteSurfaceBufferImpl(reply, retval.sequence, retval.buffer) != GSERROR_OK ||
172            bedataimpl->WriteToParcel(reply) != GSERROR_OK || !retval.fence->WriteToMessageParcel(reply) ||
173            !reply.WriteUInt32Vector(retval.deletingBuffers))) {
174        return IPC_STUB_WRITE_PARCEL_ERR;
175    } else if (sRet != GSERROR_OK && !reply.WriteBool(retval.isConnected)) {
176        return IPC_STUB_WRITE_PARCEL_ERR;
177    }
178
179    if (isActiveGame) {
180        endTimeNs = std::chrono::duration_cast<std::chrono::nanoseconds>(
181            std::chrono::steady_clock::now().time_since_epoch()).count();
182        Rosen::FrameReport::GetInstance().SetDequeueBufferTime(name_, (endTimeNs - startTimeNs));
183    }
184
185    return ERR_NONE;
186}
187
188int32_t BufferQueueProducer::RequestBuffersRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
189{
190    std::vector<RequestBufferReturnValue> retvalues;
191    std::vector<sptr<BufferExtraData>> bedataimpls;
192    BufferRequestConfig config = {};
193    uint32_t num = 0;
194
195    arguments.ReadUint32(num);
196    ReadRequestConfig(arguments, config);
197    if (num == 0 || num > SURFACE_MAX_QUEUE_SIZE) {
198        return ERR_NONE;
199    }
200    retvalues.resize(num);
201    bedataimpls.reserve(num);
202
203    for (uint32_t i = 0; i < num; ++i) {
204        sptr<BufferExtraData> data = new BufferExtraDataImpl;
205        bedataimpls.emplace_back(data);
206    }
207    GSError sRet = RequestBuffers(config, bedataimpls, retvalues);
208    if (!reply.WriteInt32(sRet)) {
209        return IPC_STUB_WRITE_PARCEL_ERR;
210    }
211    if (sRet == GSERROR_OK || sRet == GSERROR_NO_BUFFER) {
212        num = static_cast<uint32_t>(retvalues.size());
213        if (!reply.WriteUint32(num)) {
214            return IPC_STUB_WRITE_PARCEL_ERR;
215        }
216        for (uint32_t i = 0; i < num; ++i) {
217            if (WriteSurfaceBufferImpl(reply, retvalues[i].sequence, retvalues[i].buffer) != GSERROR_OK ||
218                bedataimpls[i]->WriteToParcel(reply) != GSERROR_OK ||
219                !retvalues[i].fence->WriteToMessageParcel(reply) ||
220                !reply.WriteUInt32Vector(retvalues[i].deletingBuffers)) {
221                return IPC_STUB_WRITE_PARCEL_ERR;
222            }
223        }
224    } else if (sRet != GSERROR_OK && !reply.WriteBool(retvalues[0].isConnected)) {
225        return IPC_STUB_WRITE_PARCEL_ERR;
226    }
227    return ERR_NONE;
228}
229
230int32_t BufferQueueProducer::GetProducerInitInfoRemote(MessageParcel &arguments,
231    MessageParcel &reply, MessageOption &option)
232{
233    ProducerInitInfo info;
234    sptr<IRemoteObject> token = arguments.ReadRemoteObject();
235    if (token == nullptr || !arguments.ReadString(info.appName)) {
236        if (!reply.WriteInt32(GSERROR_INVALID_ARGUMENTS)) {
237            return IPC_STUB_WRITE_PARCEL_ERR;
238        }
239        return ERR_INVALID_DATA;
240    }
241    (void)GetProducerInitInfo(info);
242    if (!reply.WriteInt32(info.width) || !reply.WriteInt32(info.height) || !reply.WriteUint64(info.uniqueId) ||
243        !reply.WriteString(info.name) || !reply.WriteBool(info.isInHebcList)) {
244        return IPC_STUB_WRITE_PARCEL_ERR;
245    }
246
247    bool result = HandleDeathRecipient(token);
248    if (!reply.WriteInt32(result ? GSERROR_OK : SURFACE_ERROR_UNKOWN)) {
249        return IPC_STUB_WRITE_PARCEL_ERR;
250    }
251    return ERR_NONE;
252}
253
254int32_t BufferQueueProducer::CancelBufferRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
255{
256    uint32_t sequence;
257    sptr<BufferExtraData> bedataimpl = new BufferExtraDataImpl;
258
259    sequence = arguments.ReadUint32();
260    if (bedataimpl->ReadFromParcel(arguments) != GSERROR_OK) {
261        return ERR_INVALID_REPLY;
262    }
263
264    GSError sRet = CancelBuffer(sequence, bedataimpl);
265    if (!reply.WriteInt32(sRet)) {
266        return IPC_STUB_WRITE_PARCEL_ERR;
267    }
268    return ERR_NONE;
269}
270
271int32_t BufferQueueProducer::FlushBufferRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
272{
273    uint32_t sequence;
274    BufferFlushConfigWithDamages config;
275    sptr<BufferExtraData> bedataimpl = new BufferExtraDataImpl;
276    int64_t startTimeNs = 0;
277    int64_t endTimeNs = 0;
278    bool isActiveGame = false;
279    int32_t connectedPid = 0;
280    {
281        std::lock_guard<std::mutex> lock(mutex_);
282        connectedPid = connectedPid_;
283    }
284    isActiveGame = Rosen::FrameReport::GetInstance().IsActiveGameWithPid(connectedPid);
285    if (isActiveGame) {
286        startTimeNs = std::chrono::duration_cast<std::chrono::nanoseconds>(
287            std::chrono::steady_clock::now().time_since_epoch()).count();
288    }
289
290    sequence = arguments.ReadUint32();
291    if (bedataimpl->ReadFromParcel(arguments) != GSERROR_OK) {
292        return ERR_INVALID_REPLY;
293    }
294
295    sptr<SyncFence> fence = SyncFence::ReadFromMessageParcel(arguments);
296    if (ReadFlushConfig(arguments, config) != GSERROR_OK) {
297        return ERR_INVALID_REPLY;
298    }
299
300    GSError sRet = FlushBuffer(sequence, bedataimpl, fence, config);
301    if (!reply.WriteInt32(sRet)) {
302        return IPC_STUB_WRITE_PARCEL_ERR;
303    }
304
305    if (isActiveGame) {
306        uint64_t uniqueId = GetUniqueId();
307        endTimeNs = std::chrono::duration_cast<std::chrono::nanoseconds>(
308            std::chrono::steady_clock::now().time_since_epoch()).count();
309        Rosen::FrameReport::GetInstance().SetQueueBufferTime(uniqueId, name_, (endTimeNs - startTimeNs));
310        Rosen::FrameReport::GetInstance().Report(name_);
311    }
312
313    return ERR_NONE;
314}
315
316int32_t BufferQueueProducer::FlushBuffersRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
317{
318    std::vector<uint32_t> sequences;
319    std::vector<BufferFlushConfigWithDamages> configs;
320    std::vector<sptr<BufferExtraData>> bedataimpls;
321    std::vector<sptr<SyncFence>> fences;
322    arguments.ReadUInt32Vector(&sequences);
323    if (sequences.size() == 0 || sequences.size() > SURFACE_MAX_QUEUE_SIZE) {
324        return ERR_NONE;
325    }
326    for (size_t i = 0; i < sequences.size(); ++i) {
327        sptr<BufferExtraData> bedataimpl = new BufferExtraDataImpl;
328        if (bedataimpl->ReadFromParcel(arguments) != GSERROR_OK) {
329            return ERR_INVALID_REPLY;
330        }
331        bedataimpls.emplace_back(bedataimpl);
332        sptr<SyncFence> fence = SyncFence::ReadFromMessageParcel(arguments);
333        fences.emplace_back(fence);
334        BufferFlushConfigWithDamages config;
335        if (ReadFlushConfig(arguments, config) != GSERROR_OK) {
336            return ERR_INVALID_REPLY;
337        }
338        configs.emplace_back(config);
339    }
340
341    GSError sRet = FlushBuffers(sequences, bedataimpls, fences, configs);
342    if (!reply.WriteInt32(sRet)) {
343        return IPC_STUB_WRITE_PARCEL_ERR;
344    }
345    return ERR_NONE;
346}
347
348int32_t BufferQueueProducer::GetLastFlushedBufferRemote(MessageParcel &arguments,
349    MessageParcel &reply, MessageOption &option)
350{
351    sptr<SurfaceBuffer> buffer;
352    sptr<SyncFence> fence;
353    float matrix[BUFFER_MATRIX_SIZE];
354    bool isUseNewMatrix = arguments.ReadBool();
355    GSError sRet = GetLastFlushedBuffer(buffer, fence, matrix, isUseNewMatrix);
356    if (!reply.WriteInt32(sRet)) {
357        return IPC_STUB_WRITE_PARCEL_ERR;
358    }
359    if (sRet == GSERROR_OK) {
360        uint32_t sequence = buffer->GetSeqNum();
361        if (WriteSurfaceBufferImpl(reply, sequence, buffer) != GSERROR_OK ||
362            buffer->WriteBufferRequestConfig(reply) != GSERROR_OK) {
363            return IPC_STUB_WRITE_PARCEL_ERR;
364        }
365        std::vector<float> writeMatrixVector(matrix, matrix + sizeof(matrix) / sizeof(float));
366        if (!fence->WriteToMessageParcel(reply) || !reply.WriteFloatVector(writeMatrixVector)) {
367            return IPC_STUB_WRITE_PARCEL_ERR;
368        }
369    }
370    return ERR_NONE;
371}
372
373int32_t BufferQueueProducer::AttachBufferToQueueRemote(MessageParcel &arguments,
374    MessageParcel &reply, MessageOption &option)
375{
376    sptr<SurfaceBuffer> buffer = nullptr;
377    uint32_t sequence;
378    GSError ret = ReadSurfaceBufferImpl(arguments, sequence, buffer);
379    if (ret != GSERROR_OK || buffer == nullptr) {
380        if (!reply.WriteInt32(SURFACE_ERROR_UNKOWN)) {
381            return IPC_STUB_WRITE_PARCEL_ERR;
382        }
383        return ERR_INVALID_DATA;
384    }
385    ret = buffer->ReadBufferRequestConfig(arguments);
386    if (ret != GSERROR_OK) {
387        if (!reply.WriteInt32(SURFACE_ERROR_UNKOWN)) {
388            return IPC_STUB_WRITE_PARCEL_ERR;
389        }
390        return ERR_INVALID_DATA;
391    }
392    ret = AttachBufferToQueue(buffer);
393    if (!reply.WriteInt32(ret)) {
394        return IPC_STUB_WRITE_PARCEL_ERR;
395    }
396    return ERR_NONE;
397}
398
399int32_t BufferQueueProducer::DetachBufferFromQueueRemote(MessageParcel &arguments,
400    MessageParcel &reply, MessageOption &option)
401{
402    sptr<SurfaceBuffer> buffer = nullptr;
403    uint32_t sequence;
404    GSError ret = ReadSurfaceBufferImpl(arguments, sequence, buffer);
405    if (ret != GSERROR_OK || buffer == nullptr) {
406        if (!reply.WriteInt32(SURFACE_ERROR_UNKOWN)) {
407            return IPC_STUB_WRITE_PARCEL_ERR;
408        }
409        return ERR_INVALID_DATA;
410    }
411    ret = DetachBufferFromQueue(buffer);
412    if (!reply.WriteInt32(ret)) {
413        return IPC_STUB_WRITE_PARCEL_ERR;
414    }
415    return ERR_NONE;
416}
417
418int32_t BufferQueueProducer::AttachBufferRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
419{
420    sptr<SurfaceBuffer> buffer;
421    uint32_t sequence;
422    int32_t timeOut;
423    GSError ret = ReadSurfaceBufferImpl(arguments, sequence, buffer);
424    if (ret != GSERROR_OK || buffer == nullptr) {
425        if (!reply.WriteInt32(ret)) {
426            return IPC_STUB_WRITE_PARCEL_ERR;
427        }
428        return ERR_INVALID_DATA;
429    }
430    timeOut = arguments.ReadInt32();
431
432    ret = AttachBuffer(buffer, timeOut);
433    if (!reply.WriteInt32(ret)) {
434        return IPC_STUB_WRITE_PARCEL_ERR;
435    }
436    return ERR_NONE;
437}
438
439int32_t BufferQueueProducer::DetachBufferRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
440{
441    return ERR_NONE;
442}
443
444int32_t BufferQueueProducer::GetQueueSizeRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
445{
446    if (!reply.WriteInt32(GetQueueSize())) {
447        return IPC_STUB_WRITE_PARCEL_ERR;
448    }
449    return ERR_NONE;
450}
451
452int32_t BufferQueueProducer::SetQueueSizeRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
453{
454    uint32_t queueSize = arguments.ReadUint32();
455    GSError sRet = SetQueueSize(queueSize);
456    if (!reply.WriteInt32(sRet)) {
457        return IPC_STUB_WRITE_PARCEL_ERR;
458    }
459    return ERR_NONE;
460}
461
462int32_t BufferQueueProducer::GetNameRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
463{
464    std::string name;
465    auto sRet = bufferQueue_->GetName(name);
466    if (!reply.WriteInt32(sRet)) {
467        return IPC_STUB_WRITE_PARCEL_ERR;
468    }
469    if (sRet == GSERROR_OK && !reply.WriteString(name)) {
470        return IPC_STUB_WRITE_PARCEL_ERR;
471    }
472    return ERR_NONE;
473}
474
475int32_t BufferQueueProducer::GetNameAndUniqueIdRemote(MessageParcel &arguments, MessageParcel &reply,
476                                                      MessageOption &option)
477{
478    std::string name = "not init";
479    uint64_t uniqueId = 0;
480    auto ret = GetNameAndUniqueId(name, uniqueId);
481    if (!reply.WriteInt32(ret)) {
482        return IPC_STUB_WRITE_PARCEL_ERR;
483    }
484    if (ret == GSERROR_OK && (!reply.WriteString(name) || !reply.WriteUint64(uniqueId))) {
485        return IPC_STUB_WRITE_PARCEL_ERR;
486    }
487    return ERR_NONE;
488}
489
490int32_t BufferQueueProducer::GetDefaultWidthRemote(MessageParcel &arguments, MessageParcel &reply,
491                                                   MessageOption &option)
492{
493    if (!reply.WriteInt32(GetDefaultWidth())) {
494        return IPC_STUB_WRITE_PARCEL_ERR;
495    }
496    return ERR_NONE;
497}
498
499int32_t BufferQueueProducer::GetDefaultHeightRemote(MessageParcel &arguments, MessageParcel &reply,
500                                                    MessageOption &option)
501{
502    if (!reply.WriteInt32(GetDefaultHeight())) {
503        return IPC_STUB_WRITE_PARCEL_ERR;
504    }
505    return ERR_NONE;
506}
507
508int32_t BufferQueueProducer::SetDefaultUsageRemote(MessageParcel &arguments, MessageParcel &reply,
509                                                   MessageOption &option)
510{
511    uint64_t usage = arguments.ReadUint64();
512    GSError sRet = SetDefaultUsage(usage);
513    if (!reply.WriteInt32(sRet)) {
514        return IPC_STUB_WRITE_PARCEL_ERR;
515    }
516    return ERR_NONE;
517}
518
519int32_t BufferQueueProducer::GetDefaultUsageRemote(MessageParcel &arguments, MessageParcel &reply,
520                                                   MessageOption &option)
521{
522    if (!reply.WriteUint64(GetDefaultUsage())) {
523        return IPC_STUB_WRITE_PARCEL_ERR;
524    }
525    return ERR_NONE;
526}
527
528int32_t BufferQueueProducer::GetUniqueIdRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
529{
530    if (!reply.WriteUint64(GetUniqueId())) {
531        return IPC_STUB_WRITE_PARCEL_ERR;
532    }
533    return ERR_NONE;
534}
535
536int32_t BufferQueueProducer::CleanCacheRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
537{
538    bool cleanAll = arguments.ReadBool();
539    if (!reply.WriteInt32(CleanCache(cleanAll))) {
540        return IPC_STUB_WRITE_PARCEL_ERR;
541    }
542    return ERR_NONE;
543}
544
545int32_t BufferQueueProducer::GoBackgroundRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
546{
547    if (!reply.WriteInt32(GoBackground())) {
548        return IPC_STUB_WRITE_PARCEL_ERR;
549    }
550    return ERR_NONE;
551}
552
553int32_t BufferQueueProducer::RegisterReleaseListenerRemote(MessageParcel &arguments,
554    MessageParcel &reply, MessageOption &option)
555{
556    sptr<IRemoteObject> listenerObject = arguments.ReadRemoteObject();
557    if (listenerObject == nullptr) {
558        if (!reply.WriteInt32(GSERROR_INVALID_ARGUMENTS)) {
559            return IPC_STUB_WRITE_PARCEL_ERR;
560        }
561        return ERR_INVALID_REPLY;
562    }
563    sptr<IProducerListener> listener = iface_cast<IProducerListener>(listenerObject);
564    GSError sRet = RegisterReleaseListener(listener);
565    if (!reply.WriteInt32(sRet)) {
566        return IPC_STUB_WRITE_PARCEL_ERR;
567    }
568    return ERR_NONE;
569}
570
571int32_t BufferQueueProducer::UnRegisterReleaseListenerRemote(MessageParcel &arguments,
572    MessageParcel &reply, MessageOption &option)
573{
574    GSError sRet = UnRegisterReleaseListener();
575    if (!reply.WriteInt32(sRet)) {
576        return IPC_STUB_WRITE_PARCEL_ERR;
577    }
578    return ERR_NONE;
579}
580
581int32_t BufferQueueProducer::SetTransformRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
582{
583    GraphicTransformType transform = static_cast<GraphicTransformType>(arguments.ReadUint32());
584    GSError sRet = SetTransform(transform);
585    if (!reply.WriteInt32(sRet)) {
586        return IPC_STUB_WRITE_PARCEL_ERR;
587    }
588    return ERR_NONE;
589}
590
591int32_t BufferQueueProducer::IsSupportedAllocRemote(MessageParcel &arguments, MessageParcel &reply,
592                                                    MessageOption &option)
593{
594    std::vector<BufferVerifyAllocInfo> infos;
595    ReadVerifyAllocInfo(arguments, infos);
596
597    std::vector<bool> supporteds;
598    GSError sRet = IsSupportedAlloc(infos, supporteds);
599    if (!reply.WriteInt32(sRet)) {
600        return IPC_STUB_WRITE_PARCEL_ERR;
601    }
602    if (sRet == GSERROR_OK && !reply.WriteBoolVector(supporteds)) {
603        return IPC_STUB_WRITE_PARCEL_ERR;
604    }
605
606    return ERR_NONE;
607}
608
609int32_t BufferQueueProducer::ConnectRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
610{
611    GSError sRet = Connect();
612    if (!reply.WriteInt32(sRet)) {
613        return IPC_STUB_WRITE_PARCEL_ERR;
614    }
615    return ERR_NONE;
616}
617
618int32_t BufferQueueProducer::DisconnectRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
619{
620    GSError sRet = Disconnect();
621    if (!reply.WriteInt32(sRet)) {
622        return IPC_STUB_WRITE_PARCEL_ERR;
623    }
624    return ERR_NONE;
625}
626
627int32_t BufferQueueProducer::SetScalingModeRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
628{
629    uint32_t sequence = arguments.ReadUint32();
630    ScalingMode scalingMode = static_cast<ScalingMode>(arguments.ReadInt32());
631    GSError sRet = SetScalingMode(sequence, scalingMode);
632    if (!reply.WriteInt32(sRet)) {
633        return IPC_STUB_WRITE_PARCEL_ERR;
634    }
635    return ERR_NONE;
636}
637
638int32_t BufferQueueProducer::SetScalingModeV2Remote(MessageParcel &arguments, MessageParcel &reply,
639                                                    MessageOption &option)
640{
641    ScalingMode scalingMode = static_cast<ScalingMode>(arguments.ReadInt32());
642    GSError sRet = SetScalingMode(scalingMode);
643    if (!reply.WriteInt32(sRet)) {
644        return IPC_STUB_WRITE_PARCEL_ERR;
645    }
646    return ERR_NONE;
647}
648
649int32_t BufferQueueProducer::SetBufferHoldRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
650{
651    bool hold = arguments.ReadBool();
652    GSError sRet = SetBufferHold(hold);
653    if (!reply.WriteInt32(sRet)) {
654        return IPC_STUB_WRITE_PARCEL_ERR;
655    }
656    return ERR_NONE;
657}
658
659int32_t BufferQueueProducer::SetMetaDataRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
660{
661    uint32_t sequence = arguments.ReadUint32();
662    std::vector<GraphicHDRMetaData> metaData;
663    if (ReadHDRMetaData(arguments, metaData) != GSERROR_OK) {
664        return GSERROR_BINDER;
665    }
666    GSError sRet = SetMetaData(sequence, metaData);
667    if (!reply.WriteInt32(sRet)) {
668        return IPC_STUB_WRITE_PARCEL_ERR;
669    }
670    return ERR_NONE;
671}
672
673int32_t BufferQueueProducer::SetMetaDataSetRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
674{
675    uint32_t sequence = arguments.ReadUint32();
676    GraphicHDRMetadataKey key = static_cast<GraphicHDRMetadataKey>(arguments.ReadUint32());
677    std::vector<uint8_t> metaData;
678    if (ReadHDRMetaDataSet(arguments, metaData) != GSERROR_OK) {
679        return GSERROR_BINDER;
680    }
681    GSError sRet = SetMetaDataSet(sequence, key, metaData);
682    if (!reply.WriteInt32(sRet)) {
683        return IPC_STUB_WRITE_PARCEL_ERR;
684    }
685    return ERR_NONE;
686}
687
688int32_t BufferQueueProducer::SetTunnelHandleRemote(MessageParcel &arguments, MessageParcel &reply,
689                                                   MessageOption &option)
690{
691    sptr<SurfaceTunnelHandle> handle = nullptr;
692    if (arguments.ReadBool()) {
693        handle = new SurfaceTunnelHandle();
694        if (ReadExtDataHandle(arguments, handle) != GSERROR_OK) {
695            return GSERROR_BINDER;
696        }
697    }
698    GSError sRet = SetTunnelHandle(handle);
699    if (!reply.WriteInt32(sRet)) {
700        return IPC_STUB_WRITE_PARCEL_ERR;
701    }
702    return ERR_NONE;
703}
704
705int32_t BufferQueueProducer::GetPresentTimestampRemote(MessageParcel &arguments, MessageParcel &reply,
706                                                       MessageOption &option)
707{
708    uint32_t sequence = arguments.ReadUint32();
709    GraphicPresentTimestampType type = static_cast<GraphicPresentTimestampType>(arguments.ReadUint32());
710    int64_t time = 0;
711    GSError sRet = GetPresentTimestamp(sequence, type, time);
712    if (!reply.WriteInt32(sRet)) {
713        return IPC_STUB_WRITE_PARCEL_ERR;
714    }
715    if (sRet == GSERROR_OK && !reply.WriteInt64(time)) {
716        return IPC_STUB_WRITE_PARCEL_ERR;
717    }
718    return ERR_NONE;
719}
720
721int32_t BufferQueueProducer::GetTransformRemote(
722    MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
723{
724    GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_BUTT;
725    auto ret = GetTransform(transform);
726    if (ret != GSERROR_OK) {
727        if (!reply.WriteInt32(static_cast<int32_t>(ret))) {
728            return IPC_STUB_WRITE_PARCEL_ERR;
729        }
730        return ERR_INVALID_REPLY;
731    }
732
733    if (!reply.WriteInt32(GSERROR_OK) || !reply.WriteUint32(static_cast<uint32_t>(transform))) {
734        return IPC_STUB_WRITE_PARCEL_ERR;
735    }
736
737    return ERR_NONE;
738}
739
740int32_t BufferQueueProducer::SetTransformHintRemote(MessageParcel &arguments,
741    MessageParcel &reply, MessageOption &option)
742{
743    GraphicTransformType transformHint = static_cast<GraphicTransformType>(arguments.ReadUint32());
744    GSError sRet = SetTransformHint(transformHint);
745    if (!reply.WriteInt32(sRet)) {
746        return IPC_STUB_WRITE_PARCEL_ERR;
747    }
748    return ERR_NONE;
749}
750
751int32_t BufferQueueProducer::GetTransformHintRemote(
752    MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
753{
754    GraphicTransformType transformHint = GraphicTransformType::GRAPHIC_ROTATE_BUTT;
755    auto ret = GetTransformHint(transformHint);
756    if (ret != GSERROR_OK) {
757        if (!reply.WriteInt32(static_cast<int32_t>(ret))) {
758            return IPC_STUB_WRITE_PARCEL_ERR;
759        }
760        return ERR_INVALID_REPLY;
761    }
762
763    if (!reply.WriteInt32(GSERROR_OK) || !reply.WriteUint32(static_cast<uint32_t>(transformHint))) {
764        return IPC_STUB_WRITE_PARCEL_ERR;
765    }
766
767    return ERR_NONE;
768}
769
770int32_t BufferQueueProducer::SetSurfaceSourceTypeRemote(MessageParcel &arguments,
771    MessageParcel &reply, MessageOption &option)
772{
773    OHSurfaceSource sourceType = static_cast<OHSurfaceSource>(arguments.ReadUint32());
774    GSError sRet = SetSurfaceSourceType(sourceType);
775    if (!reply.WriteInt32(sRet)) {
776        return IPC_STUB_WRITE_PARCEL_ERR;
777    }
778    return ERR_NONE;
779}
780
781int32_t BufferQueueProducer::GetSurfaceSourceTypeRemote(
782    MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
783{
784    OHSurfaceSource sourceType = OHSurfaceSource::OH_SURFACE_SOURCE_DEFAULT;
785    auto ret = GetSurfaceSourceType(sourceType);
786    if (ret != GSERROR_OK) {
787        if (!reply.WriteInt32(static_cast<int32_t>(ret))) {
788            return IPC_STUB_WRITE_PARCEL_ERR;
789        }
790        return ERR_INVALID_REPLY;
791    }
792
793    if (!reply.WriteInt32(GSERROR_OK) || !reply.WriteUint32(static_cast<uint32_t>(sourceType))) {
794        return IPC_STUB_WRITE_PARCEL_ERR;
795    }
796
797    return ERR_NONE;
798}
799
800int32_t BufferQueueProducer::SetSurfaceAppFrameworkTypeRemote(
801    MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
802{
803    std::string appFrameworkType = arguments.ReadString();
804    GSError sRet = SetSurfaceAppFrameworkType(appFrameworkType);
805    if (!reply.WriteInt32(sRet)) {
806        return IPC_STUB_WRITE_PARCEL_ERR;
807    }
808    return ERR_NONE;
809}
810
811int32_t BufferQueueProducer::GetSurfaceAppFrameworkTypeRemote(
812    MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
813{
814    std::string appFrameworkType = "";
815    auto ret = GetSurfaceAppFrameworkType(appFrameworkType);
816    if (ret != GSERROR_OK) {
817        if (!reply.WriteInt32(static_cast<int32_t>(ret))) {
818            return IPC_STUB_WRITE_PARCEL_ERR;
819        }
820        return ERR_INVALID_REPLY;
821    }
822
823    if (!reply.WriteInt32(GSERROR_OK) || !reply.WriteString(appFrameworkType)) {
824        return IPC_STUB_WRITE_PARCEL_ERR;
825    }
826
827    return ERR_NONE;
828}
829
830int32_t BufferQueueProducer::SetHdrWhitePointBrightnessRemote(
831    MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
832{
833    float brightness = arguments.ReadFloat();
834    GSError sRet = SetHdrWhitePointBrightness(brightness);
835    if (!reply.WriteInt32(sRet)) {
836        return IPC_STUB_WRITE_PARCEL_ERR;
837    }
838    return ERR_NONE;
839}
840
841int32_t BufferQueueProducer::SetSdrWhitePointBrightnessRemote(
842    MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
843{
844    float brightness = arguments.ReadFloat();
845    GSError sRet = SetSdrWhitePointBrightness(brightness);
846    if (!reply.WriteInt32(sRet)) {
847        return IPC_STUB_WRITE_PARCEL_ERR;
848    }
849    return ERR_NONE;
850}
851
852int32_t BufferQueueProducer::AcquireLastFlushedBufferRemote(
853    MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
854{
855    sptr<SurfaceBuffer> buffer;
856    sptr<SyncFence> fence;
857    float matrix[BUFFER_MATRIX_SIZE];
858    bool isUseNewMatrix = arguments.ReadBool();
859    GSError sRet = AcquireLastFlushedBuffer(buffer, fence, matrix, BUFFER_MATRIX_SIZE, isUseNewMatrix);
860    if (!reply.WriteInt32(sRet)) {
861        return IPC_STUB_WRITE_PARCEL_ERR;
862    }
863    if (sRet == GSERROR_OK) {
864        uint32_t sequence = buffer->GetSeqNum();
865        if (WriteSurfaceBufferImpl(reply, sequence, buffer) != GSERROR_OK ||
866            buffer->WriteBufferRequestConfig(reply) != GSERROR_OK) {
867            return IPC_STUB_WRITE_PARCEL_ERR;
868        }
869        std::vector<float> writeMatrixVector(matrix, matrix + sizeof(matrix) / sizeof(float));
870        if (!fence->WriteToMessageParcel(reply) || !reply.WriteFloatVector(writeMatrixVector)) {
871            return IPC_STUB_WRITE_PARCEL_ERR;
872        }
873    }
874    return ERR_NONE;
875}
876
877int32_t BufferQueueProducer::ReleaseLastFlushedBufferRemote(
878    MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
879{
880    uint32_t sequence = arguments.ReadUint32();
881    GSError sRet = ReleaseLastFlushedBuffer(sequence);
882    if (!reply.WriteInt32(sRet)) {
883        return IPC_STUB_WRITE_PARCEL_ERR;
884    }
885    return ERR_NONE;
886}
887
888int32_t BufferQueueProducer::SetGlobalAlphaRemote(MessageParcel &arguments, MessageParcel &reply, MessageOption &option)
889{
890    int32_t alpha = arguments.ReadInt32();
891    GSError sRet = SetGlobalAlpha(alpha);
892    if (!reply.WriteInt32(sRet)) {
893        return IPC_STUB_WRITE_PARCEL_ERR;
894    }
895    return ERR_NONE;
896}
897
898GSError BufferQueueProducer::AcquireLastFlushedBuffer(sptr<SurfaceBuffer> &buffer,
899    sptr<SyncFence> &fence, float matrix[16], uint32_t matrixSize, bool isUseNewMatrix)
900{
901    if (bufferQueue_ == nullptr) {
902        return SURFACE_ERROR_UNKOWN;
903    }
904    return bufferQueue_->AcquireLastFlushedBuffer(buffer, fence, matrix, matrixSize, isUseNewMatrix);
905}
906
907GSError BufferQueueProducer::ReleaseLastFlushedBuffer(uint32_t sequence)
908{
909    if (bufferQueue_ == nullptr) {
910        return SURFACE_ERROR_UNKOWN;
911    }
912    return bufferQueue_->ReleaseLastFlushedBuffer(sequence);
913}
914
915GSError BufferQueueProducer::RequestBuffer(const BufferRequestConfig &config, sptr<BufferExtraData> &bedata,
916                                           RequestBufferReturnValue &retval)
917{
918    if (bufferQueue_ == nullptr) {
919        return SURFACE_ERROR_UNKOWN;
920    }
921
922    retval.isConnected = false;
923    auto ret = Connect();
924    if (ret != SURFACE_ERROR_OK) {
925        return ret;
926    }
927    retval.isConnected = true;
928    return bufferQueue_->RequestBuffer(config, bedata, retval);
929}
930
931GSError BufferQueueProducer::RequestBuffers(const BufferRequestConfig &config,
932    std::vector<sptr<BufferExtraData>> &bedata, std::vector<RequestBufferReturnValue> &retvalues)
933{
934    if (bufferQueue_ == nullptr) {
935        return SURFACE_ERROR_UNKOWN;
936    }
937    retvalues[0].isConnected = false;
938    auto ret = Connect();
939    if (ret != SURFACE_ERROR_OK) {
940        return ret;
941    }
942    bufferQueue_->SetBatchHandle(true);
943    for (size_t i = 0; i < retvalues.size(); ++i) {
944        ret = bufferQueue_->RequestBuffer(config, bedata[i], retvalues[i]);
945        if (ret != GSERROR_OK) {
946            retvalues.resize(i);
947            break;
948        }
949    }
950    bufferQueue_->SetBatchHandle(false);
951    if (retvalues.size() == 0) {
952        retvalues.resize(1);
953        retvalues[0].isConnected = true;
954        return ret;
955    }
956    return GSERROR_OK;
957}
958
959GSError BufferQueueProducer::GetProducerInitInfo(ProducerInitInfo &info)
960{
961    if (bufferQueue_ == nullptr) {
962        return SURFACE_ERROR_UNKOWN;
963    }
964    return bufferQueue_->GetProducerInitInfo(info);
965}
966
967GSError BufferQueueProducer::CancelBuffer(uint32_t sequence, sptr<BufferExtraData> bedata)
968{
969    if (bufferQueue_ == nullptr) {
970        return SURFACE_ERROR_UNKOWN;
971    }
972    return bufferQueue_->CancelBuffer(sequence, bedata);
973}
974
975GSError BufferQueueProducer::FlushBuffer(uint32_t sequence, sptr<BufferExtraData> bedata,
976                                         sptr<SyncFence> fence, BufferFlushConfigWithDamages &config)
977{
978    if (bufferQueue_ == nullptr) {
979        return SURFACE_ERROR_UNKOWN;
980    }
981    return bufferQueue_->FlushBuffer(sequence, bedata, fence, config);
982}
983
984GSError BufferQueueProducer::FlushBuffers(const std::vector<uint32_t> &sequences,
985    const std::vector<sptr<BufferExtraData>> &bedata,
986    const std::vector<sptr<SyncFence>> &fences,
987    const std::vector<BufferFlushConfigWithDamages> &configs)
988{
989    if (bufferQueue_ == nullptr) {
990        return SURFACE_ERROR_UNKOWN;
991    }
992    GSError ret;
993    for (size_t i = 0; i < sequences.size(); ++i) {
994        ret = bufferQueue_->FlushBuffer(sequences[i], bedata[i], fences[i], configs[i]);
995        if (ret != GSERROR_OK) {
996            BLOGE("FlushBuffer failed: %{public}d, uniqueId: %{public}" PRIu64 ".", ret, uniqueId_);
997            return ret;
998        }
999    }
1000    return ret;
1001}
1002
1003GSError BufferQueueProducer::GetLastFlushedBuffer(sptr<SurfaceBuffer>& buffer,
1004    sptr<SyncFence>& fence, float matrix[16], bool isUseNewMatrix)
1005{
1006    if (bufferQueue_ == nullptr) {
1007        return SURFACE_ERROR_UNKOWN;
1008    }
1009    return bufferQueue_->GetLastFlushedBuffer(buffer, fence, matrix, BUFFER_MATRIX_SIZE, isUseNewMatrix);
1010}
1011
1012GSError BufferQueueProducer::AttachBufferToQueue(sptr<SurfaceBuffer> buffer)
1013{
1014    if (bufferQueue_ == nullptr) {
1015        return SURFACE_ERROR_UNKOWN;
1016    }
1017    return bufferQueue_->AttachBufferToQueue(buffer, InvokerType::PRODUCER_INVOKER);
1018}
1019
1020GSError BufferQueueProducer::DetachBufferFromQueue(sptr<SurfaceBuffer> buffer)
1021{
1022    if (bufferQueue_ == nullptr) {
1023        return SURFACE_ERROR_UNKOWN;
1024    }
1025    return bufferQueue_->DetachBufferFromQueue(buffer, InvokerType::PRODUCER_INVOKER);
1026}
1027
1028GSError BufferQueueProducer::AttachBuffer(sptr<SurfaceBuffer>& buffer)
1029{
1030    int32_t timeOut = 0;
1031    return AttachBuffer(buffer, timeOut);
1032}
1033
1034GSError BufferQueueProducer::AttachBuffer(sptr<SurfaceBuffer>& buffer, int32_t timeOut)
1035{
1036    if (bufferQueue_ == nullptr) {
1037        return GSERROR_INVALID_ARGUMENTS;
1038    }
1039    return bufferQueue_->AttachBuffer(buffer, timeOut);
1040}
1041
1042GSError BufferQueueProducer::DetachBuffer(sptr<SurfaceBuffer>& buffer)
1043{
1044    if (bufferQueue_ == nullptr) {
1045        return GSERROR_INVALID_ARGUMENTS;
1046    }
1047
1048    return bufferQueue_->DetachBuffer(buffer);
1049}
1050
1051uint32_t BufferQueueProducer::GetQueueSize()
1052{
1053    if (bufferQueue_ == nullptr) {
1054        return 0;
1055    }
1056    return bufferQueue_->GetQueueSize();
1057}
1058
1059GSError BufferQueueProducer::SetQueueSize(uint32_t queueSize)
1060{
1061    if (bufferQueue_ == nullptr) {
1062        return GSERROR_INVALID_ARGUMENTS;
1063    }
1064    return bufferQueue_->SetQueueSize(queueSize);
1065}
1066
1067GSError BufferQueueProducer::GetName(std::string &name)
1068{
1069    if (bufferQueue_ == nullptr) {
1070        return GSERROR_INVALID_ARGUMENTS;
1071    }
1072    return bufferQueue_->GetName(name);
1073}
1074
1075int32_t BufferQueueProducer::GetDefaultWidth()
1076{
1077    if (bufferQueue_ == nullptr) {
1078        return 0;
1079    }
1080    return bufferQueue_->GetDefaultWidth();
1081}
1082
1083int32_t BufferQueueProducer::GetDefaultHeight()
1084{
1085    if (bufferQueue_ == nullptr) {
1086        return 0;
1087    }
1088    return bufferQueue_->GetDefaultHeight();
1089}
1090
1091GSError BufferQueueProducer::SetDefaultUsage(uint64_t usage)
1092{
1093    if (bufferQueue_ == nullptr) {
1094        return GSERROR_INVALID_ARGUMENTS;
1095    }
1096    return bufferQueue_->SetDefaultUsage(usage);
1097}
1098
1099uint64_t BufferQueueProducer::GetDefaultUsage()
1100{
1101    if (bufferQueue_ == nullptr) {
1102        return 0;
1103    }
1104    return bufferQueue_->GetDefaultUsage();
1105}
1106
1107uint64_t BufferQueueProducer::GetUniqueId()
1108{
1109    if (bufferQueue_ == nullptr) {
1110        return 0;
1111    }
1112    return bufferQueue_->GetUniqueId();
1113}
1114
1115GSError BufferQueueProducer::CleanCache(bool cleanAll)
1116{
1117    if (bufferQueue_ == nullptr) {
1118        return GSERROR_INVALID_ARGUMENTS;
1119    }
1120
1121    {
1122        std::lock_guard<std::mutex> lock(mutex_);
1123        auto ret = CheckConnectLocked();
1124        if (ret != GSERROR_OK) {
1125            return ret;
1126        }
1127    }
1128
1129    return bufferQueue_->CleanCache(cleanAll);
1130}
1131
1132GSError BufferQueueProducer::GoBackground()
1133{
1134    if (bufferQueue_ == nullptr) {
1135        return GSERROR_INVALID_ARGUMENTS;
1136    }
1137
1138    {
1139        std::lock_guard<std::mutex> lock(mutex_);
1140        auto ret = CheckConnectLocked();
1141        if (ret != GSERROR_OK) {
1142            return ret;
1143        }
1144    }
1145    return bufferQueue_->SetProducerCacheCleanFlag(true);
1146}
1147
1148GSError BufferQueueProducer::RegisterReleaseListener(sptr<IProducerListener> listener)
1149{
1150    if (bufferQueue_ == nullptr) {
1151        return GSERROR_INVALID_ARGUMENTS;
1152    }
1153    return bufferQueue_->RegisterProducerReleaseListener(listener);
1154}
1155
1156GSError BufferQueueProducer::UnRegisterReleaseListener()
1157{
1158    if (bufferQueue_ == nullptr) {
1159        return GSERROR_INVALID_ARGUMENTS;
1160    }
1161    return bufferQueue_->UnRegisterProducerReleaseListener();
1162}
1163
1164bool BufferQueueProducer::HandleDeathRecipient(sptr<IRemoteObject> token)
1165{
1166    std::lock_guard<std::mutex> lock(mutex_);
1167    if (token_ != nullptr) {
1168        token_->RemoveDeathRecipient(producerSurfaceDeathRecipient_);
1169    }
1170    token_ = token;
1171    return token_->AddDeathRecipient(producerSurfaceDeathRecipient_);
1172}
1173
1174GSError BufferQueueProducer::SetTransform(GraphicTransformType transform)
1175{
1176    std::lock_guard<std::mutex> lock(mutex_);
1177    if (bufferQueue_ == nullptr) {
1178        return GSERROR_INVALID_ARGUMENTS;
1179    }
1180    return bufferQueue_->SetTransform(transform);
1181}
1182
1183GSError BufferQueueProducer::GetTransform(GraphicTransformType &transform)
1184{
1185    std::lock_guard<std::mutex> lock(mutex_);
1186    if (bufferQueue_ == nullptr) {
1187        transform = GraphicTransformType::GRAPHIC_ROTATE_BUTT;
1188        return GSERROR_INVALID_ARGUMENTS;
1189    }
1190    transform = bufferQueue_->GetTransform();
1191    return GSERROR_OK;
1192}
1193
1194GSError BufferQueueProducer::SetTransformHint(GraphicTransformType transformHint)
1195{
1196    std::lock_guard<std::mutex> lock(mutex_);
1197    if (bufferQueue_ == nullptr) {
1198        return GSERROR_INVALID_ARGUMENTS;
1199    }
1200    return bufferQueue_->SetTransformHint(transformHint);
1201}
1202
1203GSError BufferQueueProducer::GetTransformHint(GraphicTransformType &transformHint)
1204{
1205    std::lock_guard<std::mutex> lock(mutex_);
1206    if (bufferQueue_ == nullptr) {
1207        transformHint = GraphicTransformType::GRAPHIC_ROTATE_BUTT;
1208        return GSERROR_INVALID_ARGUMENTS;
1209    }
1210    transformHint = bufferQueue_->GetTransformHint();
1211    return GSERROR_OK;
1212}
1213
1214GSError BufferQueueProducer::SetSurfaceSourceType(OHSurfaceSource sourceType)
1215{
1216    std::lock_guard<std::mutex> lock(mutex_);
1217    if (bufferQueue_ == nullptr) {
1218        return GSERROR_INVALID_ARGUMENTS;
1219    }
1220    return bufferQueue_->SetSurfaceSourceType(sourceType);
1221}
1222
1223GSError BufferQueueProducer::GetSurfaceSourceType(OHSurfaceSource &sourceType)
1224{
1225    std::lock_guard<std::mutex> lock(mutex_);
1226    if (bufferQueue_ == nullptr) {
1227        sourceType = OHSurfaceSource::OH_SURFACE_SOURCE_DEFAULT;
1228        return GSERROR_INVALID_ARGUMENTS;
1229    }
1230    sourceType = bufferQueue_->GetSurfaceSourceType();
1231    return GSERROR_OK;
1232}
1233
1234GSError BufferQueueProducer::SetSurfaceAppFrameworkType(std::string appFrameworkType)
1235{
1236    std::lock_guard<std::mutex> lock(mutex_);
1237    if (bufferQueue_ == nullptr) {
1238        return GSERROR_INVALID_ARGUMENTS;
1239    }
1240    return bufferQueue_->SetSurfaceAppFrameworkType(appFrameworkType);
1241}
1242
1243GSError BufferQueueProducer::GetSurfaceAppFrameworkType(std::string &appFrameworkType)
1244{
1245    std::lock_guard<std::mutex> lock(mutex_);
1246    if (bufferQueue_ == nullptr) {
1247        appFrameworkType = "";
1248        return GSERROR_INVALID_ARGUMENTS;
1249    }
1250    appFrameworkType = bufferQueue_->GetSurfaceAppFrameworkType();
1251    return GSERROR_OK;
1252}
1253
1254GSError BufferQueueProducer::SetHdrWhitePointBrightness(float brightness)
1255{
1256    std::lock_guard<std::mutex> lock(mutex_);
1257    if (bufferQueue_ == nullptr) {
1258        return SURFACE_ERROR_UNKOWN;
1259    }
1260    return bufferQueue_->SetHdrWhitePointBrightness(brightness);
1261}
1262
1263GSError BufferQueueProducer::SetSdrWhitePointBrightness(float brightness)
1264{
1265    std::lock_guard<std::mutex> lock(mutex_);
1266    if (bufferQueue_ == nullptr) {
1267        return SURFACE_ERROR_UNKOWN;
1268    }
1269    return bufferQueue_->SetSdrWhitePointBrightness(brightness);
1270}
1271
1272GSError BufferQueueProducer::IsSupportedAlloc(const std::vector<BufferVerifyAllocInfo> &infos,
1273                                              std::vector<bool> &supporteds)
1274{
1275    if (bufferQueue_ == nullptr) {
1276        return GSERROR_INVALID_ARGUMENTS;
1277    }
1278
1279    return bufferQueue_->IsSupportedAlloc(infos, supporteds);
1280}
1281
1282GSError BufferQueueProducer::GetNameAndUniqueId(std::string& name, uint64_t& uniqueId)
1283{
1284    if (bufferQueue_ == nullptr) {
1285        return GSERROR_INVALID_ARGUMENTS;
1286    }
1287    uniqueId = GetUniqueId();
1288    return GetName(name);
1289}
1290
1291GSError BufferQueueProducer::Connect()
1292{
1293    std::lock_guard<std::mutex> lock(mutex_);
1294    auto callingPid = GetCallingPid();
1295    if (connectedPid_ != 0 && connectedPid_ != callingPid) {
1296        BLOGW("connected by: %{public}d, request by: %{public}d , uniqueId: %{public}" PRIu64 ".",
1297            connectedPid_, callingPid, uniqueId_);
1298        return SURFACE_ERROR_CONSUMER_IS_CONNECTED;
1299    }
1300    connectedPid_ = callingPid;
1301    return SURFACE_ERROR_OK;
1302}
1303
1304GSError BufferQueueProducer::Disconnect()
1305{
1306    if (bufferQueue_ == nullptr) {
1307        return SURFACE_ERROR_UNKOWN;
1308    }
1309
1310    {
1311        std::lock_guard<std::mutex> lock(mutex_);
1312        auto ret = CheckConnectLocked();
1313        if (ret != GSERROR_OK) {
1314            return ret;
1315        }
1316        connectedPid_ = 0;
1317    }
1318    return bufferQueue_->CleanCache(false);
1319}
1320
1321GSError BufferQueueProducer::SetScalingMode(uint32_t sequence, ScalingMode scalingMode)
1322{
1323    if (bufferQueue_ == nullptr) {
1324        return GSERROR_INVALID_ARGUMENTS;
1325    }
1326    return bufferQueue_->SetScalingMode(sequence, scalingMode);
1327}
1328
1329GSError BufferQueueProducer::SetScalingMode(ScalingMode scalingMode)
1330{
1331    if (bufferQueue_ == nullptr) {
1332        return GSERROR_INVALID_ARGUMENTS;
1333    }
1334    return bufferQueue_->SetScalingMode(scalingMode);
1335}
1336
1337GSError BufferQueueProducer::SetBufferHold(bool hold)
1338{
1339    if (bufferQueue_ == nullptr) {
1340        return GSERROR_INVALID_ARGUMENTS;
1341    }
1342    return bufferQueue_->SetBufferHold(hold);
1343}
1344
1345GSError BufferQueueProducer::SetMetaData(uint32_t sequence, const std::vector<GraphicHDRMetaData> &metaData)
1346{
1347    if (bufferQueue_ == nullptr) {
1348        return GSERROR_INVALID_ARGUMENTS;
1349    }
1350
1351    return bufferQueue_->SetMetaData(sequence, metaData);
1352}
1353
1354GSError BufferQueueProducer::SetMetaDataSet(uint32_t sequence, GraphicHDRMetadataKey key,
1355                                            const std::vector<uint8_t> &metaData)
1356{
1357    if (bufferQueue_ == nullptr) {
1358        return GSERROR_INVALID_ARGUMENTS;
1359    }
1360
1361    return bufferQueue_->SetMetaDataSet(sequence, key, metaData);
1362}
1363
1364GSError BufferQueueProducer::SetTunnelHandle(const sptr<SurfaceTunnelHandle> &handle)
1365{
1366    if (bufferQueue_ == nullptr) {
1367        return GSERROR_INVALID_ARGUMENTS;
1368    }
1369    return bufferQueue_->SetTunnelHandle(handle);
1370}
1371
1372GSError BufferQueueProducer::SetTunnelHandle(const GraphicExtDataHandle *handle)
1373{
1374    sptr<SurfaceTunnelHandle> tunnelHandle = new SurfaceTunnelHandle();
1375    if (tunnelHandle->SetHandle(handle) != GSERROR_OK) {
1376        return GSERROR_INVALID_OPERATING;
1377    }
1378    return bufferQueue_->SetTunnelHandle(tunnelHandle);
1379}
1380
1381GSError BufferQueueProducer::GetPresentTimestamp(uint32_t sequence, GraphicPresentTimestampType type, int64_t &time)
1382{
1383    if (bufferQueue_ == nullptr) {
1384        return GSERROR_INVALID_ARGUMENTS;
1385    }
1386    return bufferQueue_->GetPresentTimestamp(sequence, type, time);
1387}
1388
1389bool BufferQueueProducer::GetStatus() const
1390{
1391    if (bufferQueue_ == nullptr) {
1392        return false;
1393    }
1394    return bufferQueue_->GetStatus();
1395}
1396
1397void BufferQueueProducer::SetStatus(bool status)
1398{
1399    if (bufferQueue_ == nullptr) {
1400        return;
1401    }
1402    bufferQueue_->SetStatus(status);
1403}
1404
1405GSError BufferQueueProducer::SetGlobalAlpha(int32_t alpha)
1406{
1407    if (bufferQueue_ == nullptr) {
1408        return SURFACE_ERROR_UNKOWN;
1409    }
1410    return bufferQueue_->SetGlobalAlpha(alpha);
1411}
1412
1413sptr<NativeSurface> BufferQueueProducer::GetNativeSurface()
1414{
1415    return nullptr;
1416}
1417
1418void BufferQueueProducer::OnBufferProducerRemoteDied()
1419{
1420    if (bufferQueue_ == nullptr) {
1421        return;
1422    }
1423
1424    {
1425        std::lock_guard<std::mutex> lock(mutex_);
1426        if (connectedPid_ == 0) {
1427            BLOGD("no connections, uniqueId: %{public}" PRIu64 ".", uniqueId_);
1428            return;
1429        }
1430        connectedPid_ = 0;
1431    }
1432    bufferQueue_->CleanCache(false);
1433}
1434
1435BufferQueueProducer::ProducerSurfaceDeathRecipient::ProducerSurfaceDeathRecipient(
1436    wptr<BufferQueueProducer> producer) : producer_(producer)
1437{
1438}
1439
1440void BufferQueueProducer::ProducerSurfaceDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>& remoteObject)
1441{
1442    auto remoteToken = remoteObject.promote();
1443    if (remoteToken == nullptr) {
1444        BLOGW("can't promote remote object.");
1445        return;
1446    }
1447
1448    auto producer = producer_.promote();
1449    if (producer == nullptr) {
1450        BLOGD("producer is nullptr");
1451        return;
1452    }
1453
1454    if (producer->token_ != remoteToken) {
1455        BLOGD("token doesn't match, ignore it, uniqueId: %{public}" PRIu64 ".", producer->GetUniqueId());
1456        return;
1457    }
1458    BLOGD("remote object died, uniqueId: %{public}" PRIu64 ".", producer->GetUniqueId());
1459    producer->OnBufferProducerRemoteDied();
1460}
1461}; // namespace OHOS
1462