1/*
2 * Copyright (c) 2020-2022 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#ifndef GRAPHIC_LITE_SURFACE_BUFFER_IMPL_H
17#define GRAPHIC_LITE_SURFACE_BUFFER_IMPL_H
18
19#include <map>
20#include <pthread.h>
21#include "buffer_common.h"
22#include "ipc_skeleton.h"
23#include "surface_buffer.h"
24
25namespace OHOS {
26enum BufferState {
27    BUFFER_STATE_NONE = 0,
28    BUFFER_STATE_REQUEST,
29    BUFFER_STATE_FLUSH,
30    BUFFER_STATE_ACQUIRE,
31    BUFFER_STATE_RELEASE
32};
33
34enum BufferDataType {
35    BUFFER_DATA_TYPE_NONE,
36    BUFFER_DATA_TYPE_INT_32,
37    BUFFER_DATA_TYPE_INT_64,
38    BUFFER_DATA_TYPE_MAX,
39};
40
41struct SurfaceBufferHandle {
42    int32_t key;
43    uint64_t phyAddr;
44    int32_t stride;       /* the stride of memory */
45    uint32_t reserveFds;  /* the number of reserved fd value */
46    uint32_t reserveInts; /* the number of reserved integer value */
47    bool operator == (const SurfaceBufferHandle &rHandle) const
48    {
49        return ((key == rHandle.key)
50            && (phyAddr == rHandle.phyAddr));
51    }
52};
53
54struct SurfaceBufferData {
55    SurfaceBufferHandle handle;
56    uint32_t size;
57    uint32_t usage;
58    uint8_t deletePending;
59    BufferState state;
60    void* virAddr;
61    bool operator == (const SurfaceBufferData &rData) const
62    {
63        return handle == rData.handle;
64    }
65};
66
67typedef struct {
68    void* value;
69    uint8_t size;
70    uint8_t type;
71} ExtraData;
72
73/**
74 * @brief Buffer class. Provide shared memory for graphic and multi media to use.
75 */
76class SurfaceBufferImpl : public SurfaceBuffer {
77public:
78    /**
79     * @brief Buffer Constructor.
80     */
81    SurfaceBufferImpl();
82
83    /**
84     * @brief Buffer Destructor.
85     */
86    ~SurfaceBufferImpl();
87
88    /**
89     * @brief Get buffer key, for shared virtual memory.
90     * @returns The buffer key.
91     */
92    int32_t GetKey() const
93    {
94        return bufferData_.handle.key;
95    }
96
97    /**
98     * @brief Set buffer key, for shared virtual memory.
99     * @param [in] The buffer key
100     */
101    void SetKey(int32_t key)
102    {
103        bufferData_.handle.key = key;
104    }
105
106    /**
107     * @brief Get buffer phyAddr, for shared physical memory.
108     * @returns The buffer phyAddr.
109     */
110    uint64_t GetPhyAddr() const override
111    {
112        return bufferData_.handle.phyAddr;
113    }
114
115    /**
116     * @brief Set buffer phyAddr, for shared physical memory.
117     * @param [in] The buffer phyAddr
118     */
119    void SetPhyAddr(uint64_t phyAddr)
120    {
121        bufferData_.handle.phyAddr = phyAddr;
122    }
123
124    /**
125     * @brief Get buffer stride, for shared physical memory.
126     * @returns The buffer phyAddr.
127     */
128    int32_t GetStride() const
129    {
130        return bufferData_.handle.stride;
131    }
132
133    /**
134     * @brief Set buffer stride, for shared physical memory.
135     * @param [in] The buffer phyAddr
136     */
137    void SetStride(int32_t stride)
138    {
139        bufferData_.handle.stride = stride;
140    }
141
142    /**
143     * @brief Get buffer reserveInts, for shared physical memory.
144     * @returns The buffer phyAddr.
145     */
146    uint32_t GetReserveInts() const
147    {
148        return bufferData_.handle.reserveInts;
149    }
150
151    /**
152     * @brief Set buffer reserveInts, for shared physical memory.
153     * @param [in] The buffer phyAddr
154     */
155    void SetReserveInts(uint32_t reserveInts)
156    {
157        bufferData_.handle.reserveInts = reserveInts;
158    }
159
160    /**
161     * @brief Get buffer reserveFds, for shared physical memory.
162     * @returns The buffer phyAddr.
163     */
164    uint32_t GetReserveFds() const
165    {
166        return bufferData_.handle.reserveFds;
167    }
168
169    /**
170     * @brief Set buffer reserveFds, for shared physical memory.
171     * @param [in] The buffer phyAddr
172     */
173    void SetReserveFds(uint32_t reserveFds)
174    {
175        bufferData_.handle.reserveFds = reserveFds;
176    }
177
178    /**
179     * @brief Set buffer virtual addr.
180     * @param [in] The virtual addr.
181     */
182    void SetVirAddr(void* virAddr)
183    {
184        bufferData_.virAddr = virAddr;
185    }
186
187    /**
188     * @brief Get buffer virtual addr.
189     * @returns The buffer virtual addr.
190     */
191    void* GetVirAddr() const override
192    {
193        return bufferData_.virAddr;
194    }
195
196    /**
197     * @brief Get buffer size.
198     * @returns The buffer size.
199     */
200    uint32_t GetMaxSize() const
201    {
202        return bufferData_.size;
203    }
204
205    /**
206     * @brief Set buffer size.
207     * @param [in] The buffer size
208     */
209    void SetMaxSize(uint32_t size)
210    {
211        bufferData_.size = size;
212    }
213
214    /**
215     * @brief Get buffer size.
216     * @returns The buffer size.
217     */
218    uint32_t GetSize() const override
219    {
220        if (len_ == 0) {
221            return bufferData_.size;
222        }
223        return len_;
224    }
225
226    /**
227     * @brief Set buffer size.
228     * @param [in] The buffer size
229     */
230    void SetSize(uint32_t size) override
231    {
232        if (size > bufferData_.size) {
233            GRAPHIC_LOGI("Input param is invalid");
234            return;
235        }
236        len_ = size;
237    }
238
239    /**
240     * @brief Get buffer usage. Surface alloc physical or virtual memory buffer.
241     *        All usage sees detail in OHOS::BUFFER_CONSUMER_USAGE.
242     * @returns The buffer usage.
243     */
244    uint32_t GetUsage() const
245    {
246        return bufferData_.usage;
247    }
248
249    /**
250     * @brief Set buffer usage. Surface alloc physical or virtual memory buffer.
251     *        Support usage see detail in OHOS::BUFFER_CONSUMER_USAGE.
252     *        Default is BUFFER_CONSUMER_USAGE_SORTWARE, which will alloc virtual memory buffer.
253     * @param [in] The buffer usage.
254     */
255    void SetUsage(uint32_t usage)
256    {
257        bufferData_.usage = usage;
258    }
259
260    /**
261     * @brief Get buffer delete state. If deletePending == 1, buffer will be freed when state == BUFFER_STATE_FREE.
262     * @returns [in] The buffer delete state
263     */
264    uint8_t GetDeletePending() const
265    {
266        return bufferData_.deletePending;
267    }
268
269    /**
270     * @brief Set buffer delete state. If deletePending == 1, buffer will be freed when state == BUFFER_STATE_FREE.
271     * @param [in] The buffer delete state
272     */
273    void SetDeletePending(uint8_t deletePending)
274    {
275        bufferData_.deletePending = deletePending;
276    }
277
278    /**
279     * @brief Get buffer state. Buffer state detail : BUFFER_STATE.
280     * @returns [in] The buffer state
281     */
282    BufferState GetState() const
283    {
284        return bufferData_.state;
285    }
286
287    /**
288     * @brief Set buffer state. Buffer state detail : BUFFER_STATE.
289     * @param [in] The buffer state
290     */
291
292    void SetState(BufferState newState)
293    {
294        bufferData_.state = newState;
295    }
296    /**
297     * @brief Set int32 extra data for buffer, like <key,value>.
298     * @param [in] key, unique uint32_t. If exited, will overlap.
299     * @param [in] value, value which storage the value;
300     * @returns if succeed, return 0; else return -1.
301     */
302    int32_t SetInt32(uint32_t key, int32_t value) override;
303
304    /**
305     * @brief Get int32 extra data for buffer, like <key,value>.
306     * @param [in] key, unique uint32_t..
307     * @param [out] value, value which storage the value;
308     * @returns if succeed, return 0; else return -1;
309     */
310    int32_t GetInt32(uint32_t key, int32_t& value) override;
311
312    /**
313     * @brief Set int64 extra data for buffer, like <key,value>.
314     * @param [in] key, unique uint32_t. If exited, will overlap.
315     * @param [in] value, value which storage the value;
316     * @returns if succeed, return 0; else return -1.
317     */
318    int32_t SetInt64(uint32_t key, int64_t value) override;
319
320    /**
321     * @brief Get int64 extra data for buffer, like <key,value>.
322     * @param [in] key, unique uint32_t..
323     * @param [out] value, value which storage the value;
324     * @returns if succeed, return 0; else return -1;
325     */
326    int32_t GetInt64(uint32_t key, int64_t& value) override;
327
328    /**
329     * @brief Verify the two surface buffer same or not.
330     * @param [in] The other SurfaceBufferImpl object
331     * @returns Is same or not.
332     */
333    bool equals(const SurfaceBufferImpl& buffer) const
334    {
335        return bufferData_ == buffer.bufferData_;
336    }
337
338    /**
339     * @brief Get buffer attr from ipc object.
340     * @param [in] IpcIo pointer.
341     */
342    void ReadFromIpcIo(IpcIo& io);
343
344    /**
345     * @brief Write buffer attr to ipc object.
346     * @param [in] IpcIo object.
347     */
348    void WriteToIpcIo(IpcIo& io);
349
350    /**
351     * @brief Copy buffer extra data from input buffer to self
352     * @param [in] buffer pointer.
353     */
354    void CopyExtraData(SurfaceBufferImpl& buffer);
355
356    /**
357     * @brief Clear buffer extra data.
358     */
359    void ClearExtraData();
360
361private:
362    /**
363     * Set extra data for buffer, like <key,value>.
364     * @key, unique uint32_t. If exited, will overlap;
365     * @type, value type. Current support see detail enum OHOS::BUFFER_DATA_TYPE
366     * @data, value pointer, which storage the value;
367     * @size, value length.
368     */
369    int32_t SetData(uint32_t key, uint8_t type, const void* data, uint8_t size);
370    int32_t GetData(uint32_t key, uint8_t* type, void** data, uint8_t* size);
371    struct SurfaceBufferData bufferData_;
372    std::map<uint32_t, ExtraData> extDatas_;
373    uint32_t len_;
374};
375} // end namespace
376#endif
377