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 
16 #include <buffer_handle.h>
17 #include <gtest/gtest.h>
18 #include "hdf_log.h"
19 #include "v1_0/include/idisplay_buffer.h"
20 #include "v1_0/display_composer_type.h"
21 #include "v1_0/display_buffer_type.h"
22 #include "v2_0/icodec_image.h"
23 #define HDF_LOG_TAG codec_jpeg_test
24 
25 using namespace std;
26 using namespace testing::ext;
27 using namespace OHOS::HDI::Display::Buffer::V1_0;
28 using namespace OHOS::HDI::Display::Composer::V1_0;
29 using namespace OHOS::HDI::Codec::Image::V2_0;
30 namespace {
31 constexpr int32_t WIDTH = 640;
32 constexpr int32_t HEIGHT = 480;
33 constexpr uint32_t NORMAL_BUFFER_SIZE = 1000;
34 constexpr uint32_t CODEC_IMAGE_MAX_BUFFER_SIZE = 50 * 1024 *1024;
35 static OHOS::sptr<ICodecImage> hdiJpeg_;
36 static IDisplayBuffer *hdiBuffer_;
37 class CodecHdiJpegTest : public testing::Test {
38 public:
39 
InitOutBuffer(CodecImageBuffer & outBuffer)40     void InitOutBuffer(CodecImageBuffer &outBuffer)
41     {
42         AllocInfo alloc = {
43             .width = WIDTH,
44             .height = HEIGHT,
45             .usage = HBM_USE_CPU_READ | HBM_USE_CPU_WRITE | HBM_USE_MEM_DMA,
46             .format = PIXEL_FMT_YCBCR_420_SP};
47 
48         BufferHandle *bufferHandle = nullptr;
49         auto err = hdiBuffer_->AllocMem(alloc, bufferHandle);
50         if (err != HDF_SUCCESS) {
51             return;
52         }
53         outBuffer.buffer = new NativeBuffer(bufferHandle);
54     }
55 
SetUpTestCase()56     static void SetUpTestCase()
57     {
58         hdiJpeg_ = ICodecImage::Get();
59         hdiBuffer_ = IDisplayBuffer::Get();
60     }
TearDownTestCase()61     static void TearDownTestCase()
62     {
63         hdiJpeg_ = nullptr;
64         hdiBuffer_ = nullptr;
65     }
SetUp()66     void SetUp()
67     {
68         if (hdiJpeg_ != nullptr) {
69             hdiJpeg_->Init(CODEC_IMAGE_JPEG);
70         }
71     }
TearDown()72     void TearDown()
73     {
74         if (hdiJpeg_ != nullptr) {
75             hdiJpeg_->DeInit(CODEC_IMAGE_JPEG);
76         }
77     }
78 };
79 
80 HWTEST_F(CodecHdiJpegTest, HdfCodecHdiGetImageCapabilityTest_001, TestSize.Level1)
81 {
82     ASSERT_TRUE(hdiJpeg_ != nullptr);
83     std::vector<CodecImageCapability> capList;
84     auto ret = hdiJpeg_->GetImageCapability(capList);
85     ASSERT_EQ(ret, HDF_SUCCESS);
86 }
87 
88 HWTEST_F(CodecHdiJpegTest, HdfCodecHdiAllocateInBufferTest_001, TestSize.Level1)
89 {
90     ASSERT_TRUE(hdiJpeg_ != nullptr);
91     struct CodecImageBuffer inBuffer;
92     auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, 0, CODEC_IMAGE_JPEG);
93     ASSERT_NE(ret, HDF_SUCCESS);
94 }
95 
96 HWTEST_F(CodecHdiJpegTest, HdfCodecHdiAllocateInBufferTest_002, TestSize.Level1)
97 {
98     ASSERT_TRUE(hdiJpeg_ != nullptr);
99     struct CodecImageBuffer inBuffer;
100     auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, CODEC_IMAGE_MAX_BUFFER_SIZE + 1, CODEC_IMAGE_JPEG);
101     ASSERT_NE(ret, HDF_SUCCESS);
102 }
103 
104 HWTEST_F(CodecHdiJpegTest, HdfCodecHdiAllocateAndFreeInBufferTest_001, TestSize.Level1)
105 {
106     ASSERT_TRUE(hdiJpeg_ != nullptr);
107     struct CodecImageBuffer inBuffer;
108     auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG);
109     ASSERT_EQ(ret, HDF_SUCCESS);
110     ret = hdiJpeg_->FreeInBuffer(inBuffer);
111     ASSERT_EQ(ret, HDF_SUCCESS);
112 }
113 
114 HWTEST_F(CodecHdiJpegTest, HdfCodecHdiFreeInBufferTest_001, TestSize.Level1)
115 {
116     ASSERT_TRUE(hdiJpeg_ != nullptr);
117     struct CodecImageBuffer inBuffer;
118     inBuffer.id = -1;
119     inBuffer.fenceFd = -1;
120     auto ret = hdiJpeg_->FreeInBuffer(inBuffer);
121     ASSERT_EQ(ret, HDF_SUCCESS);
122 }
123 
124 HWTEST_F(CodecHdiJpegTest, HdfCodecHdiDoJpegDecodeTest_001, TestSize.Level1)
125 {
126     ASSERT_TRUE(hdiJpeg_ != nullptr);
127     struct CodecImageBuffer inBuffer;
128     struct CodecImageBuffer outBuffer;
129     struct CodecJpegDecInfo decInfo;
130     inBuffer.fenceFd = -1;
131     outBuffer.fenceFd = -1;
132     auto ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo);
133     ASSERT_NE(ret, HDF_SUCCESS);
134 }
135 
136 HWTEST_F(CodecHdiJpegTest, HdfCodecHdiDoJpegDecodeTest_002, TestSize.Level1)
137 {
138     ASSERT_TRUE(hdiJpeg_ != nullptr);
139     struct CodecImageBuffer inBuffer;
140     auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG);
141     ASSERT_EQ(ret, HDF_SUCCESS);
142 
143     struct CodecImageBuffer outBuffer;
144     struct CodecJpegDecInfo decInfo;
145     outBuffer.fenceFd = -1;
146     ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo);
147     EXPECT_TRUE(ret != HDF_SUCCESS);
148     ret = hdiJpeg_->FreeInBuffer(inBuffer);
149     ASSERT_EQ(ret, HDF_SUCCESS);
150 }
151 
152 HWTEST_F(CodecHdiJpegTest, HdfCodecHdiDoJpegDecodeTest_003, TestSize.Level1)
153 {
154     ASSERT_TRUE(hdiJpeg_ != nullptr);
155     struct CodecImageBuffer inBuffer;
156     auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG);
157     ASSERT_EQ(ret, HDF_SUCCESS);
158 
159     ASSERT_TRUE(hdiBuffer_ != nullptr);
160     struct CodecImageBuffer outBuffer;
161     InitOutBuffer(outBuffer);
162     outBuffer.fenceFd = -1;
163 
164     struct CodecJpegDecInfo decInfo;
165     ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo);
166     EXPECT_TRUE(ret != HDF_SUCCESS);
167     ret = hdiJpeg_->FreeInBuffer(inBuffer);
168     ASSERT_EQ(ret, HDF_SUCCESS);
169 }
170 
171 }  // namespace
172