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_BUFFER_QUEUEU_PRODUCER_H
17 #define GRAPHIC_LITE_BUFFER_QUEUEU_PRODUCER_H
18 
19 #include "buffer_producer.h"
20 #include "buffer_queue.h"
21 #include "ibuffer_consumer_listener.h"
22 #include "surface_buffer.h"
23 
24 namespace OHOS {
25 /**
26  * @brief Surface producer class. In multi process, deal with surface client producer ipc request;
27  *        In single process, BufferQueueProducer is producer to request buffer, flush buffer,
28  *        cancel buffer and set buffer attr.
29  */
30 class BufferQueueProducer : public BufferProducer {
31 public:
32     /**
33      * @brief Surface Buffer Client Producer Constructor.
34      * @param [in] BufferQueue bufferQueue, to request buffer, flush buffer,
35     *              cancel buffer and set buffer attr.
36      */
37     explicit BufferQueueProducer(BufferQueue* bufferQueue);
38 
39     /**
40      * @brief Surface Buffer Producer Destructor.
41      */
42     ~BufferQueueProducer();
43 
44     /**
45      * @brief Request buffer. Surface producer requests buffer.
46      *        Waiting until some buffer could used.
47      * @param [in] whether waiting or not.
48      *        wait = 1. waiting util get surface buffer.
49      *        wait = 0. No wait to get surface buffer.
50      * @returns buffer pointer.
51      */
52     SurfaceBufferImpl* RequestBuffer(uint8_t wait) override;
53 
54     /**
55      * @brief Flush buffer for consumer acquire. When producer flush buffer, to
56      *        push to dirty list, and call back to consumer that buffer is available to acquire.
57      * @param [in] SurfaceBufferImpl pointer, Which buffer could acquire for consumer.
58      * @returns Flush buffer succeed or not.
59      *        0 is succeed; other is failed.
60      */
61     int32_t FlushBuffer(SurfaceBufferImpl* buffer) override;
62 
63     /**
64      * @brief Enqueue buffer for consumer acquire and notice consumer to acquire it.
65      * @param [in] SurfaceBufferImpl, Which buffer could acquire for consumer.
66      * @returns Enqueue buffer succeed or not.
67      *        0 is succeed; other is failed.
68      */
69     int32_t EnqueueBuffer(SurfaceBufferImpl& buffer);
70 
71     /**
72      * @brief Cancel buffer. Producer cancel this buffer, buffer will push to free list for request it.
73      * @param [in] SurfaceBufferImpl pointer, push it back to free list for request it.
74      */
75     void Cancel(SurfaceBufferImpl* buffer) override;
76 
77     /**
78      * @brief Set queue size, the surface could alloc max buffer count.
79      *        Default is 1. Max count is 10.
80      * @param [in] queueSize. Could allocate buffer count.
81      */
82     void SetQueueSize(uint8_t queueSize) override;
83 
84     /**
85      * @brief Get queue size, the surface could alloc max buffer count.
86      * @returns queue size.
87      */
88     uint8_t GetQueueSize() override;
89 
90     /**
91      * @brief Set width and height to calculate the buffer size.
92      * @param [in] width, Buffer width.
93      * @param [in] height, Buffer height.
94      */
95     void SetWidthAndHeight(uint32_t width, uint32_t height) override;
96 
97     /**
98      * @brief Get width, buffer width to calculate the buffer size..
99      * @returns width, Buffer width.
100      */
101     uint32_t GetWidth() override;
102 
103     /**
104      * @brief Get height, buffer height to calculate the buffer size..
105      * @returns height, Buffer height.
106      */
107     uint32_t GetHeight() override;
108 
109     /**
110      * @brief Set format, to calculate the buffer size.
111      *        Default is IMAGE_PIXEL_FORMAT_RGB565. See all formats in OHOS::ImageFormat
112      * @param [in] format, Buffer format.
113      */
114     void SetFormat(uint32_t format) override;
115 
116     /**
117      * @brief Get format, buffer format to calculate the buffer size..
118      * @returns format, Buffer format.
119      */
120     uint32_t GetFormat() override;
121 
122     /**
123      * @brief Set stride alignment bytes. Default alignment is 4 bytes.
124      * @param [in] strideAlignment, Buffer stride alignment
125      */
126     void SetStrideAlignment(uint32_t strideAlignment) override;
127 
128     /**
129      * @brief Get stride alignment bytes. Default alignment is 4 bytes.
130      * @returns strideAlignment, Buffer stride alignment.
131      */
132     uint32_t GetStrideAlignment() override;
133 
134     /**
135      * @brief Get bytes of one stride which calculate by width, format and stride alignment.
136      * @returns The stride
137      */
138     uint32_t GetStride() override;
139 
140     /**
141      * @brief Set buffer size. Surface alloc buffer size, no need to calculate by width, height, format...
142      * @param [in] The buffer size
143      */
144     void SetSize(uint32_t size) override;
145 
146     /**
147      * @brief Get buffer size. Surface alloc buffer size.
148      *        The size is setted by SetSize() or calculated by width, height, format...
149      * @returns The buffer size.
150      */
151     uint32_t GetSize() override;
152 
153     /**
154      * @brief Set buffer usage. Surface alloc physical or virtual memory buffer.
155      *        Support usage see detail in OHOS::BUFFER_CONSUMER_USAGE.
156      *        Default is BUFFER_CONSUMER_USAGE_SORTWARE, which will alloc virtual memory buffer.
157      * @param [in] The buffer usage.
158      */
159     void SetUsage(uint32_t usage) override;
160 
161     /**
162      * @brief Get buffer usage. Surface alloc physical or virtual memory buffer.
163      *        All usage sees detail in OHOS::BUFFER_CONSUMER_USAGE.
164      * @returns The buffer usage.
165      */
166     uint32_t GetUsage() override;
167 
168     /**
169      * @brief Set user data. Construct a local map to store all the user-data.
170      * @param [in] key.
171      * @param [in] value.
172      */
173     void SetUserData(const std::string& key, const std::string& value) override;
174 
175     /**
176      * @brief Get user data. Get the value from local map.
177      * @returns value refers to the key.
178      */
179     std::string GetUserData(const std::string& key) override;
180 
181     /**
182      * @brief Register consumer listener, when some buffer is available for acquired.
183      *        One producer only has one consumer listener.
184      * @param [in], IBufferConsumerListener listener.
185      */
186     void RegisterConsumerListener(IBufferConsumerListener& listener);
187 
188     /**
189      * @brief Unregister consumer listener, remove the consumer listener.
190      *        One producer only has one consumer listener, So when invoking this method,
191      *        there will have no listener.
192      */
193     void UnregisterConsumerListener();
194 
195     /**
196      * @brief Deal with the ipc msg from BufferClientProducer.
197      * @param [in] ipcMsg, ipc msg, contains request code...
198      * @param [in] IpcIo pointer, ipc msg object, contains request attr...
199      * @returns 0 is succeed; other is failed.
200      */
201     int32_t OnIpcMsg(uint32_t code, IpcIo *data, IpcIo *reply, MessageOption option);
202 private:
203     BufferQueue* bufferQueue_;
204     IBufferConsumerListener* consumerListener_;
205 };
206 } // end namespace
207 #endif
208