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