1/*
2 * Copyright (c) 2023 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#include "display_buffer_ut.h"
16#include <securec.h>
17
18#include "gtest/gtest.h"
19#include "v1_0/display_buffer_type.h"
20#include "v1_2/display_composer_type.h"
21#include "hdf_base.h"
22#include "hdf_log.h"
23
24namespace OHOS {
25namespace HDI {
26namespace Display {
27namespace TEST {
28using namespace testing::ext;
29using namespace OHOS::HDI::Display::Composer::V1_2;
30using namespace OHOS::HDI::Display::Buffer::V1_1;
31using OHOS::HDI::Display::Buffer::V1_0::AllocInfo;
32using OHOS::HDI::Display::Composer::V1_2::HBM_USE_MEM_DMA;
33using OHOS::HDI::Display::Composer::V1_2::HBM_USE_CPU_READ;
34using OHOS::HDI::Display::Composer::V1_2::HBM_USE_CPU_WRITE;
35using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_RGBX_8888;
36using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_RGBA_8888;
37using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_BGRA_8888;
38using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_YCBCR_420_SP;
39using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_YCRCB_420_SP;
40using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_YCBCR_420_P;
41using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_YCRCB_420_P;
42using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_RGB_888;
43using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_BGRX_8888;
44using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_RGBA_4444;
45using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_RGBX_4444;
46using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_BGRA_4444;
47using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_BGRX_4444;
48using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_BGR_565;
49using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_BGRA_5551;
50using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_BGRX_5551;
51using OHOS::HDI::Display::Composer::V1_1::PIXEL_FMT_RGBA_1010102;
52#ifndef DISPLAY_TEST_CHK_RETURN
53#define DISPLAY_TEST_CHK_RETURN(val, ret, ...) \
54    do {                                       \
55        if (val) {                             \
56            __VA_ARGS__;                       \
57            return (ret);                      \
58        }                                      \
59    } while (0)
60#endif
61
62const uint32_t ALLOC_SIZE_1080 = 1080; // alloc size 1080
63const uint32_t ALLOC_SIZE_1920 = 1920; // alloc size 1920
64const uint32_t ALLOC_SIZE_1280 = 1280; // alloc size 1280
65const uint32_t ALLOC_SIZE_720 = 720; // alloc size 720
66
67const AllocInfo DISPLAY_BUFFER_TEST_SETS[] = {
68    // num0
69    {
70        .width = ALLOC_SIZE_1920,
71        .height = ALLOC_SIZE_1080,
72        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
73        .format = PIXEL_FMT_RGBX_8888
74    },
75    // num1
76    {
77        .width = ALLOC_SIZE_1080,
78        .height = ALLOC_SIZE_1920,
79        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
80        .format = PIXEL_FMT_RGBX_8888
81    },
82    // num2
83    {
84        .width = ALLOC_SIZE_1280,
85        .height = ALLOC_SIZE_720,
86        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
87        .format = PIXEL_FMT_RGBX_8888
88    },
89    // num3
90    {
91        .width = ALLOC_SIZE_1080,
92        .height = ALLOC_SIZE_1920,
93        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
94        .format = PIXEL_FMT_RGBA_8888
95    },
96    // num4
97    {
98        .width = ALLOC_SIZE_1080,
99        .height = ALLOC_SIZE_1920,
100        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
101        .format = PIXEL_FMT_BGRA_8888
102    },
103    // num5
104    {
105        .width = ALLOC_SIZE_1080,
106        .height = ALLOC_SIZE_1920,
107        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
108        .format = PIXEL_FMT_YCBCR_420_SP
109    },
110    // num6
111    {
112        .width = ALLOC_SIZE_1080,
113        .height = ALLOC_SIZE_1920,
114        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
115        .format = PIXEL_FMT_YCRCB_420_SP
116    },
117    // num7
118    {
119        .width = ALLOC_SIZE_1080,
120        .height = ALLOC_SIZE_1920,
121        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
122        .format = PIXEL_FMT_YCBCR_420_P
123    },
124    // num8
125    {
126        .width = ALLOC_SIZE_1080,
127        .height = ALLOC_SIZE_1920,
128        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
129        .format = PIXEL_FMT_YCRCB_420_P
130    },
131    // num9
132    {
133        .width = ALLOC_SIZE_1080,
134        .height = ALLOC_SIZE_1920,
135        .usage = HBM_USE_MEM_DMA,
136        .format = PIXEL_FMT_RGBX_8888
137    },
138    // num10
139    {
140        .width = ALLOC_SIZE_1080,
141        .height = ALLOC_SIZE_1920,
142        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ,
143        .format = PIXEL_FMT_RGBX_8888
144    },
145    // num11
146    {
147        .width = ALLOC_SIZE_1080,
148        .height = ALLOC_SIZE_1920,
149        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_WRITE,
150        .format = PIXEL_FMT_RGBX_8888
151    },
152    //HBM_USE_CPU_HW_BOTH
153    // num12
154    {
155        .width = ALLOC_SIZE_1920,
156        .height = ALLOC_SIZE_1080,
157        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
158        .format = PIXEL_FMT_RGBX_8888
159    },
160    // num13
161    {
162        .width = ALLOC_SIZE_1080,
163        .height = ALLOC_SIZE_1920,
164        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
165        .format = PIXEL_FMT_RGBX_8888
166    },
167    // num14
168    {
169        .width = ALLOC_SIZE_1280,
170        .height = ALLOC_SIZE_720,
171        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
172        .format = PIXEL_FMT_RGBX_8888
173    },
174    // num15
175    {
176        .width = ALLOC_SIZE_1080,
177        .height = ALLOC_SIZE_1920,
178        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
179        .format = PIXEL_FMT_RGBA_8888
180    },
181    // num16
182    {
183        .width = ALLOC_SIZE_1080,
184        .height = ALLOC_SIZE_1920,
185        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
186        .format = PIXEL_FMT_BGRA_8888
187    },
188    // num17
189    {
190        .width = ALLOC_SIZE_1080,
191        .height = ALLOC_SIZE_1920,
192        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
193        .format = PIXEL_FMT_YCBCR_420_SP
194    },
195    // num18
196    {
197        .width = ALLOC_SIZE_1080,
198        .height = ALLOC_SIZE_1920,
199        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
200        .format = PIXEL_FMT_YCRCB_420_SP
201    },
202    // num19
203    {
204        .width = ALLOC_SIZE_1080,
205        .height = ALLOC_SIZE_1920,
206        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
207        .format = PIXEL_FMT_YCBCR_420_P
208    },
209    // num20
210    {
211        .width = ALLOC_SIZE_1080,
212        .height = ALLOC_SIZE_1920,
213        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
214        .format = PIXEL_FMT_YCRCB_420_P
215    },
216    // num21
217    {
218        .width = ALLOC_SIZE_1080,
219        .height = ALLOC_SIZE_1920,
220        .usage = HBM_USE_CPU_HW_BOTH,
221        .format = PIXEL_FMT_RGBX_8888
222    },
223    // num22
224    {
225        .width = ALLOC_SIZE_1080,
226        .height = ALLOC_SIZE_1920,
227        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ,
228        .format = PIXEL_FMT_RGBX_8888
229    },
230    // num23
231    {
232        .width = ALLOC_SIZE_1080,
233        .height = ALLOC_SIZE_1920,
234        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_WRITE,
235        .format = PIXEL_FMT_RGBX_8888
236    },
237#ifdef DISPLAY_COMMUNITY
238     // num24
239    {
240        .width = ALLOC_SIZE_1080,
241        .height = ALLOC_SIZE_1920,
242        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
243        .format = PIXEL_FMT_RGB_888
244    },
245    // num25
246    {
247        .width = ALLOC_SIZE_1080,
248        .height = ALLOC_SIZE_1920,
249        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
250        .format = PIXEL_FMT_BGRX_8888
251    },
252    // num26
253    {
254        .width = ALLOC_SIZE_1080,
255        .height = ALLOC_SIZE_1920,
256        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
257        .format = PIXEL_FMT_RGBA_4444
258    },
259    // num27
260    {
261        .width = ALLOC_SIZE_1080,
262        .height = ALLOC_SIZE_1920,
263        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
264        .format = PIXEL_FMT_RGBX_4444
265    },
266    // num28
267    {
268        .width = ALLOC_SIZE_1080,
269        .height = ALLOC_SIZE_1920,
270        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
271        .format = PIXEL_FMT_BGRA_4444
272    },
273    // num29
274    {
275        .width = ALLOC_SIZE_1080,
276        .height = ALLOC_SIZE_1920,
277        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
278        .format = PIXEL_FMT_BGRX_4444
279    },
280    // num30
281    {
282        .width = ALLOC_SIZE_1080,
283        .height = ALLOC_SIZE_1920,
284        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
285        .format = PIXEL_FMT_BGR_565
286    },
287    // num31
288    {
289        .width = ALLOC_SIZE_1080,
290        .height = ALLOC_SIZE_1920,
291        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
292        .format = PIXEL_FMT_BGRA_5551
293    },
294    // num32
295    {
296        .width = ALLOC_SIZE_1080,
297        .height = ALLOC_SIZE_1920,
298        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
299        .format = PIXEL_FMT_BGRX_5551
300    },
301    //HBM_USE_CPU_HW_BOTH
302    // num33
303    {
304        .width = ALLOC_SIZE_1080,
305        .height = ALLOC_SIZE_1920,
306        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
307        .format = PIXEL_FMT_RGB_888
308    },
309    // num34
310    {
311        .width = ALLOC_SIZE_1080,
312        .height = ALLOC_SIZE_1920,
313        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
314        .format = PIXEL_FMT_BGRX_8888
315    },
316    // num35
317    {
318        .width = ALLOC_SIZE_1080,
319        .height = ALLOC_SIZE_1920,
320        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
321        .format = PIXEL_FMT_RGBA_4444
322    },
323    // num36
324    {
325        .width = ALLOC_SIZE_1080,
326        .height = ALLOC_SIZE_1920,
327        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
328        .format = PIXEL_FMT_RGBX_4444
329    },
330    // num37
331    {
332        .width = ALLOC_SIZE_1080,
333        .height = ALLOC_SIZE_1920,
334        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
335        .format = PIXEL_FMT_BGRA_4444
336    },
337    // num38
338    {
339        .width = ALLOC_SIZE_1080,
340        .height = ALLOC_SIZE_1920,
341        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
342        .format = PIXEL_FMT_BGRX_4444
343    },
344    // num39
345    {
346        .width = ALLOC_SIZE_1080,
347        .height = ALLOC_SIZE_1920,
348        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
349        .format = PIXEL_FMT_BGR_565
350    },
351    // num40
352    {
353        .width = ALLOC_SIZE_1080,
354        .height = ALLOC_SIZE_1920,
355        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
356        .format = PIXEL_FMT_BGRA_5551
357    },
358    // num41
359    {
360        .width = ALLOC_SIZE_1080,
361        .height = ALLOC_SIZE_1920,
362        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
363        .format = PIXEL_FMT_BGRX_5551
364    },
365#else
366    // num42
367    {
368        .width = ALLOC_SIZE_1080,
369        .height = ALLOC_SIZE_1920,
370        .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_WRITE,
371        .format = PIXEL_FMT_RGBA_1010102
372    },
373    //HBM_USE_CPU_HW_BOTH
374    // num43
375    {
376        .width = ALLOC_SIZE_1080,
377        .height = ALLOC_SIZE_1920,
378        .usage = HBM_USE_CPU_HW_BOTH | HBM_USE_CPU_WRITE,
379        .format = PIXEL_FMT_RGBA_1010102
380    },
381#endif // DISPLAY_COMMUNITY
382};
383
384void DisplayBufferUt::SetUp()
385{
386    displayBuffer_ = IDisplayBuffer::Get();
387    if (displayBuffer_ == nullptr) {
388        HDF_LOGE("IDisplayBuffer get failed");
389        ASSERT_TRUE(0);
390    }
391}
392
393void DisplayBufferUt::TearDown()
394{
395}
396
397void DisplayBufferUt::MetadataTest(BufferHandle& handle)
398{
399    int32_t ret = displayBuffer_->RegisterBuffer(handle);
400    EXPECT_TRUE(ret == DISPLAY_NOT_SUPPORT || ret == DISPLAY_SUCCESS);
401
402    uint32_t key = 1;
403    std::vector<uint8_t> values = {1, 2, 3};
404    std::vector<uint32_t> keys = {};
405    std::vector<uint8_t> rets = {};
406    ret = displayBuffer_->SetMetadata(handle, key, values);
407    EXPECT_TRUE(ret == DISPLAY_NOT_SUPPORT || ret == DISPLAY_SUCCESS);
408    ret = displayBuffer_->GetMetadata(handle, key, rets);
409    EXPECT_TRUE(ret == DISPLAY_NOT_SUPPORT || ret == DISPLAY_SUCCESS);
410    if (ret != DISPLAY_NOT_SUPPORT) {
411        EXPECT_TRUE(rets == values);
412    }
413
414    ret = displayBuffer_->ListMetadataKeys(handle, keys);
415    EXPECT_TRUE(ret == DISPLAY_NOT_SUPPORT || ret == DISPLAY_SUCCESS);
416    if (ret != DISPLAY_NOT_SUPPORT) {
417        EXPECT_TRUE(keys.size() == 1 && keys[0] == key);
418    }
419
420    ret = displayBuffer_->EraseMetadataKey(handle, key);
421    EXPECT_TRUE(ret == DISPLAY_NOT_SUPPORT || ret == DISPLAY_SUCCESS);
422    if (ret != DISPLAY_NOT_SUPPORT) {
423        rets = {};
424        ret = displayBuffer_->GetMetadata(handle, key, rets);
425        EXPECT_TRUE(ret != DISPLAY_SUCCESS);
426    }
427}
428
429int32_t DisplayBufferUt::AllocMemTest(AllocInfo& info)
430{
431    int ret;
432    BufferHandle *buffer = nullptr;
433    const int TEST_COUNT = 40; // test 40 times
434    for (int i = 0; i < TEST_COUNT; i++) {
435        ret = displayBuffer_->AllocMem(info, buffer);
436        if (ret == DISPLAY_NOT_SUPPORT) {
437            HDF_LOGE("%{public}s: AllocMem not support, ret=%{public}d", __func__, ret);
438            return DISPLAY_SUCCESS;
439        }
440        if (ret != DISPLAY_SUCCESS || buffer == nullptr) {
441            HDF_LOGE("AllocMem failed");
442            return ret;
443        }
444        MetadataTest(*buffer);
445        void *vAddr = displayBuffer_->Mmap(*buffer);
446        if (vAddr == nullptr) {
447            HDF_LOGE("Mmap failed");
448            displayBuffer_->FreeMem(*buffer);
449            return DISPLAY_FAILURE;
450        }
451        if (info.usage & (HBM_USE_CPU_READ | HBM_USE_CPU_WRITE)) {
452            ret = displayBuffer_->InvalidateCache(*buffer);
453            if (ret != DISPLAY_SUCCESS) {
454                HDF_LOGE("InvalidateCache failed");
455                displayBuffer_->Unmap(*buffer);
456                displayBuffer_->FreeMem(*buffer);
457                return ret;
458            }
459        }
460        if (memset_s(vAddr, buffer->size, 0, buffer->size) != EOK) {
461            HDF_LOGE("Insufficient memory");
462            displayBuffer_->Unmap(*buffer);
463            displayBuffer_->FreeMem(*buffer);
464            return DISPLAY_NOMEM;
465        }
466        if (info.usage & (HBM_USE_CPU_READ | HBM_USE_CPU_WRITE)) {
467            ret = displayBuffer_->FlushCache(*buffer);
468            if (ret != DISPLAY_SUCCESS) {
469                HDF_LOGE("FlushCache failed");
470                displayBuffer_->Unmap(*buffer);
471                displayBuffer_->FreeMem(*buffer);
472                return ret;
473            }
474        }
475        displayBuffer_->Unmap(*buffer);
476        displayBuffer_->FreeMem(*buffer);
477    }
478    return DISPLAY_SUCCESS;
479}
480
481TEST_P(DisplayBufferUt, DisplayBufferUt)
482{
483    AllocInfo params = GetParam();
484    int ret = AllocMemTest(params);
485    ASSERT_TRUE(ret == DISPLAY_SUCCESS);
486}
487
488INSTANTIATE_TEST_SUITE_P(AllocTest, DisplayBufferUt, ::testing::ValuesIn(DISPLAY_BUFFER_TEST_SETS));
489} // OHOS
490} // HDI
491} // DISPLAY
492} // TEST