1 /*
2  * Copyright (c) 2024 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 <gtest/gtest.h>
17 #include "test_helper.h"
18 #include "v1_2/display_composer_type.h"
19 #include "v1_2/display_buffer_type.h"
20 #include "v1_2/include/idisplay_buffer.h"
21 
22 #define HDF_LOG_TAG codec_heif_encode_test
23 
24 namespace {
25 using namespace std;
26 using namespace testing::ext;
27 using namespace OHOS::HDI::Codec::Image::V2_0;
28 using namespace OHOS::HDI::Display::Buffer::V1_2;
29 using namespace OHOS::HDI::Display::Composer::V1_2;
30 
31 static constexpr size_t EXTERNAL_BUFFER_SIZE = 18 * 1024 * 1024;
32 static constexpr size_t META_BUFFER_SIZE = 1024;
33 
34 static uint32_t id_ = 0;
35 static OHOS::sptr<ICodecImage> hdiHeifEncoder_ = nullptr;
36 static OHOS::HDI::Display::Buffer::V1_2::IDisplayBuffer* bufferMgr_ = nullptr;
37 static uint32_t pixelFmtNv12_ = OHOS::HDI::Display::Composer::V1_2::PIXEL_FMT_YCBCR_420_SP;
38 static uint32_t pixelFmtRgba_ = OHOS::HDI::Display::Composer::V1_2::PIXEL_FMT_RGBA_8888;
39 static uint32_t unsupportedPixelFmt_ = OHOS::HDI::Display::Composer::V1_2::PIXEL_FMT_YUV_422_I;
40 
41 class CodecHdiHeifEncodeTest : public testing::Test {
42 public:
SetUpTestCase()43     static void SetUpTestCase()
44     {
45         hdiHeifEncoder_ = ICodecImage::Get();
46         bufferMgr_ = OHOS::HDI::Display::Buffer::V1_2::IDisplayBuffer::Get();
47     }
TearDownTestCase()48     static void TearDownTestCase()
49     {
50         hdiHeifEncoder_ = nullptr;
51         bufferMgr_ = nullptr;
52     }
SetUp()53     void SetUp()
54     {
55         inputImgs_.clear();
56         inputMetas_.clear();
57         refs_.clear();
58         output_ = AllocateSharedBuffer(EXTERNAL_BUFFER_SIZE);
59         filledLen_ = 0;
60     }
TearDown()61     void TearDown()
62     {
63         for (auto item : inputImgs_) {
64             FreeSharedBuffer(item.sharedProperties);
65         }
66         for (auto item : inputMetas_) {
67             FreeSharedBuffer(item.data);
68         }
69         FreeSharedBuffer(output_);
70     }
71 public:
72     enum ImgType {
73         PRIMARY_IMG,
74         AUXILIARY_IMG,
75         THUMBNAIL_IMG,
76         GAIN_MAP,
77         T_MAP
78     };
79     enum MetaType {
80         EXIF_DATA,
81         USER_DATA
82     };
83 public:
GetNextId()84     static uint32_t GetNextId()
85     {
86         return id_++;
87     }
AllocateSharedBuffer(uint32_t size)88     static SharedBuffer AllocateSharedBuffer(uint32_t size)
89     {
90         SharedBuffer sb = {
91             .fd = -1,
92             .filledLen = 0,
93             .capacity = 0
94         };
95         IF_TRUE_RETURN_VAL(size <= 0, sb);
96         int fd = AshmemCreate("ForHeifEncodeUT", size);
97         if (fd > 0) {
98             sb.fd = fd;
99             sb.filledLen = static_cast<uint32_t>(size);
100             sb.capacity = static_cast<uint32_t>(AshmemGetSize(fd));
101         } else {
102             HDF_LOGE("cannot create ashmem");
103         }
104         return sb;
105     }
106 
FreeSharedBuffer(SharedBuffer& sb)107     static void FreeSharedBuffer(SharedBuffer& sb)
108     {
109         if (sb.fd > 0) {
110             close(sb.fd);
111         }
112     }
113 
AllocateNativeBuffer(uint32_t width, uint32_t height, uint32_t pixelFmt)114     static sptr<NativeBuffer> AllocateNativeBuffer(uint32_t width, uint32_t height, uint32_t pixelFmt)
115     {
116         uint64_t usage = OHOS::HDI::Display::Composer::V1_2::HBM_USE_CPU_READ |
117                          OHOS::HDI::Display::Composer::V1_2::HBM_USE_CPU_WRITE |
118                          OHOS::HDI::Display::Composer::V1_2::HBM_USE_MEM_DMA;
119         AllocInfo alloc = {
120             .width = width,
121             .height = height,
122             .usage =  usage,
123             .format = pixelFmt
124         };
125         BufferHandle *handle = nullptr;
126         int32_t ret = bufferMgr_->AllocMem(alloc, handle);
127         if (ret != HDF_SUCCESS) {
128             HDF_LOGE("failed to alloc buffer, err [%{public}d] !", ret);
129             return nullptr;
130         }
131         sptr<NativeBuffer> imgBuffer = new NativeBuffer(handle);
132         return imgBuffer;
133     }
CreateImageItem(ImgType imageType, uint32_t pixelFmt, bool needAllocPixelBuffer = true)134     static ImageItem CreateImageItem(ImgType imageType, uint32_t pixelFmt, bool needAllocPixelBuffer = true)
135     {
136         static constexpr uint32_t ENCODE_QUALITY = 85;
137         static constexpr uint32_t PIXEL_WIDTH = 1920;
138         static constexpr uint32_t PIXEL_HEIGHT = 1080;
139         ImageItem item = {
140             .itemName = "",
141             .id = GetNextId(),
142             .pixelBuffer = nullptr,
143             .isPrimary = (imageType == PRIMARY_IMG),
144             .isHidden = (imageType != PRIMARY_IMG),
145             .compressType = "hevc",
146             .quality = ENCODE_QUALITY,
147             .liteProperties = {},
148             .sharedProperties = AllocateSharedBuffer(0)
149         };
150         if (needAllocPixelBuffer && (imageType != T_MAP)) {
151             item.pixelBuffer = AllocateNativeBuffer(PIXEL_WIDTH, PIXEL_HEIGHT, pixelFmt);
152         }
153         return item;
154     }
CreateMetaItem(MetaType type)155     static MetaItem CreateMetaItem(MetaType type)
156     {
157         MetaItem item = {
158             .itemName = (type == USER_DATA) ? "userdata" : "exif",
159             .id = GetNextId(),
160             .data = AllocateSharedBuffer(META_BUFFER_SIZE),
161             .properties = {}
162         };
163         if (type == USER_DATA) {
164             bool useCompress = true;
165             PropWriter pw;
166             (void)pw.AddData<bool>(USER_DATA_DO_COMPRESS, useCompress);
167             (void)pw.Finalize(item.properties);
168         }
169         return item;
170     }
SetValidNclxColor(ImageItem& item)171     static bool SetValidNclxColor(ImageItem& item)
172     {
173         PropWriter pw;
174         ColorType clrType = NCLX;
175         IF_TRUE_RETURN_VAL(!pw.AddData<ColorType>(COLOR_TYPE, clrType), false);
176         ColourInfo clrInfo = {
177             .colourPrimaries = 2,
178             .transferCharacteristics = 2,
179             .matrixCoefficients = 2,
180             .fullRangeFlag = false
181         };
182         IF_TRUE_RETURN_VAL(!pw.AddData<ColourInfo>(COLOR_INFO, clrInfo), false);
183         return pw.Finalize(item.liteProperties);
184     }
SetColorTypeOnly(ImageItem& item, ColorType clrType)185     static bool SetColorTypeOnly(ImageItem& item, ColorType clrType)
186     {
187         PropWriter pw;
188         IF_TRUE_RETURN_VAL(!pw.AddData<ColorType>(COLOR_TYPE, clrType), false);
189         return pw.Finalize(item.liteProperties);
190     }
SetInvalidRiccColor(ImageItem& item)191     static bool SetInvalidRiccColor(ImageItem& item)
192     {
193         PropWriter pw;
194         ColorType clrType = RICC;
195         IF_TRUE_RETURN_VAL(!pw.AddData<ColorType>(COLOR_TYPE, clrType), false);
196         IF_TRUE_RETURN_VAL(!pw.Finalize(item.liteProperties), false);
197         PropertyType propType = ICC_PROFILE;
198         size_t bufferSize = sizeof(propType);
199         item.sharedProperties = AllocateSharedBuffer(bufferSize);
200         IF_TRUE_RETURN_VAL(item.sharedProperties.fd < 0, false);
201         void *addr = mmap(nullptr, bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, item.sharedProperties.fd, 0);
202         if (addr == nullptr) {
203             close(item.sharedProperties.fd);
204             item.sharedProperties.fd = -1;
205             return false;
206         }
207         errno_t ret = memcpy_s(addr, bufferSize, reinterpret_cast<uint8_t*>(&propType), bufferSize);
208         (void)munmap(addr, bufferSize);
209         return (ret == EOK);
210     }
SetInvalidNclxColor(ImageItem& item)211     static bool SetInvalidNclxColor(ImageItem& item)
212     {
213         PropWriter pw;
214         ColourInfo clrInfo = {
215             .colourPrimaries = 2,
216             .transferCharacteristics = 2,
217             .matrixCoefficients = 2,
218             .fullRangeFlag = false
219         };
220         IF_TRUE_RETURN_VAL(!pw.AddData<ColourInfo>(COLOR_INFO, clrInfo), false);
221         return pw.Finalize(item.liteProperties);
222     }
SetPropeForTmap(ImageItem& item)223     static bool SetPropeForTmap(ImageItem& item)
224     {
225         PropWriter pw;
226         ColorType clrType = NCLX;
227         IF_TRUE_RETURN_VAL(!pw.AddData<ColorType>(COLOR_TYPE, clrType), false);
228         ColourInfo clrInfo = {
229             .colourPrimaries = 2,
230             .transferCharacteristics = 2,
231             .matrixCoefficients = 2,
232             .fullRangeFlag = false
233         };
234         IF_TRUE_RETURN_VAL(!pw.AddData<ColourInfo>(COLOR_INFO, clrInfo), false);
235         ToneMapMetadata tmapMeta;
236         static constexpr uint8_t MULTI_CHANNEL = 3;
237         tmapMeta.channelCnt = MULTI_CHANNEL;
238         tmapMeta.useBaseColorSpace = true;
239         tmapMeta.baseHdrHeadroom = {12, 23};
240         tmapMeta.alternateHdrHeadroom = {36, 62};
241         tmapMeta.channels1 = {
242             .gainMapMin = {5, 21},
243             .gainMapMax = {5, 7},
244             .gamma = {2, 7},
245             .baseOffset = {1, 3},
246             .alternateOffset = {1, 7}
247         };
248         tmapMeta.channels2 = {
249             .gainMapMin = {5, 21},
250             .gainMapMax = {5, 7},
251             .gamma = {2, 7},
252             .baseOffset = {1, 3},
253             .alternateOffset = {1, 7}
254         };
255         tmapMeta.channels3 = {
256             .gainMapMin = {5, 21},
257             .gainMapMax = {5, 7},
258             .gamma = {2, 7},
259             .baseOffset = {1, 3},
260             .alternateOffset = {1, 7}
261         };
262         IF_TRUE_RETURN_VAL(!pw.AddData<ToneMapMetadata>(TONE_MAP_METADATA, tmapMeta), false);
263         return pw.Finalize(item.liteProperties);
264     }
265 public:
266     vector<ImageItem> inputImgs_;
267     vector<MetaItem> inputMetas_;
268     vector<ItemRef> refs_;
269     SharedBuffer output_;
270     uint32_t filledLen_;
271 };
272 
273 // [OK] primary image
274 #ifdef SUPPORT_HEIF
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_001, TestSize.Level1)275 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_001, TestSize.Level1)
276 {
277     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
278     ASSERT_TRUE(bufferMgr_ != nullptr);
279     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_);
280     inputImgs_.emplace_back(primaryImageItem);
281     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
282     ASSERT_EQ(ret, HDF_SUCCESS);
283     ASSERT_TRUE(filledLen_ > 0);
284 }
285 
286 // [OK] primary image + auxl image + thumnail + userdata
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_002, TestSize.Level1)287 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_002, TestSize.Level1)
288 {
289     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
290     ASSERT_TRUE(bufferMgr_ != nullptr);
291     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
292     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
293     ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_);
294     ASSERT_TRUE(SetValidNclxColor(auxlImageItem));
295     ImageItem thumImageItem = CreateImageItem(THUMBNAIL_IMG, pixelFmtRgba_);
296     ASSERT_TRUE(SetValidNclxColor(thumImageItem));
297     refs_.emplace_back(ItemRef {
298         .type = AUXL,
299         .auxType = "",
300         .from = auxlImageItem.id,
301         .to = { primaryImageItem.id }
302     });
303     refs_.emplace_back(ItemRef {
304         .type = THMB,
305         .auxType = "",
306         .from = thumImageItem.id,
307         .to = { primaryImageItem.id }
308     });
309     inputImgs_.emplace_back(primaryImageItem);
310     inputImgs_.emplace_back(auxlImageItem);
311     inputImgs_.emplace_back(thumImageItem);
312     MetaItem metaUserData = CreateMetaItem(USER_DATA);
313     refs_.emplace_back(ItemRef {
314         .type = CDSC,
315         .auxType = "",
316         .from = metaUserData.id,
317         .to = { primaryImageItem.id }
318     });
319     inputMetas_.emplace_back(metaUserData);
320     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
321     ASSERT_EQ(ret, HDF_SUCCESS);
322     ASSERT_TRUE(filledLen_ > 0);
323 }
324 #endif
325 
326 // [FAIL] auxl image only
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_003, TestSize.Level1)327 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_003, TestSize.Level1)
328 {
329     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
330     ASSERT_TRUE(bufferMgr_ != nullptr);
331     ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_);
332     ASSERT_TRUE(SetValidNclxColor(auxlImageItem));
333     inputImgs_.emplace_back(auxlImageItem);
334     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
335     ASSERT_NE(ret, HDF_SUCCESS);
336     ASSERT_EQ(filledLen_, 0);
337 }
338 
339 // [FAIL] primary image + (image.pixelBuffer == nullptr)
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_004, TestSize.Level1)340 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_004, TestSize.Level1)
341 {
342     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
343     ASSERT_TRUE(bufferMgr_ != nullptr);
344     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_, false);
345     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
346     inputImgs_.emplace_back(primaryImageItem);
347     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
348     ASSERT_NE(ret, HDF_SUCCESS);
349     ASSERT_EQ(filledLen_, 0);
350 }
351 
352 // [FAIL] primary image + unsupported pixelFmt in image.pixelBuffer
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_005, TestSize.Level1)353 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_005, TestSize.Level1)
354 {
355     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
356     ASSERT_TRUE(bufferMgr_ != nullptr);
357     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false);
358     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
359     inputImgs_.emplace_back(primaryImageItem);
360     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
361     ASSERT_NE(ret, HDF_SUCCESS);
362     ASSERT_EQ(filledLen_, 0);
363 }
364 
365 // [FAIL] primary image + (COLOR_TYPE == NCLX) + COLOR_INFO not configured
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_006, TestSize.Level1)366 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_006, TestSize.Level1)
367 {
368     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
369     ASSERT_TRUE(bufferMgr_ != nullptr);
370     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false);
371     ASSERT_TRUE(SetColorTypeOnly(primaryImageItem, NCLX));
372     inputImgs_.emplace_back(primaryImageItem);
373     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
374     ASSERT_NE(ret, HDF_SUCCESS);
375     ASSERT_EQ(filledLen_, 0);
376 }
377 
378 // [FAIL] primary image + (COLOR_TYPE == RICC) + ICC_PROFILE not configured
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_007, TestSize.Level1)379 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_007, TestSize.Level1)
380 {
381     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
382     ASSERT_TRUE(bufferMgr_ != nullptr);
383     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false);
384     ASSERT_TRUE(SetColorTypeOnly(primaryImageItem, RICC));
385     inputImgs_.emplace_back(primaryImageItem);
386     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
387     ASSERT_NE(ret, HDF_SUCCESS);
388     ASSERT_EQ(filledLen_, 0);
389 }
390 
391 // [FAIL] primary image + (COLOR_TYPE == RICC) + SharedBuffer that store ICC_PROFILE is not properly filled
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_008, TestSize.Level1)392 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_008, TestSize.Level1)
393 {
394     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
395     ASSERT_TRUE(bufferMgr_ != nullptr);
396     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false);
397     ASSERT_TRUE(SetInvalidRiccColor(primaryImageItem));
398     inputImgs_.emplace_back(primaryImageItem);
399     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
400     ASSERT_NE(ret, HDF_SUCCESS);
401     ASSERT_EQ(filledLen_, 0);
402 }
403 
404 // [FAIL] primary image + COLOR_INFO is configured + COLOR_TYPE not configured
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_009, TestSize.Level1)405 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_009, TestSize.Level1)
406 {
407     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
408     ASSERT_TRUE(bufferMgr_ != nullptr);
409     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false);
410     ASSERT_TRUE(SetInvalidNclxColor(primaryImageItem));
411     inputImgs_.emplace_back(primaryImageItem);
412     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
413     ASSERT_NE(ret, HDF_SUCCESS);
414     ASSERT_EQ(filledLen_, 0);
415 }
416 
417 // [FAIL] auxl image is not related to primary image
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_010, TestSize.Level1)418 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_010, TestSize.Level1)
419 {
420     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
421     ASSERT_TRUE(bufferMgr_ != nullptr);
422     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
423     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
424     ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_);
425     ASSERT_TRUE(SetValidNclxColor(auxlImageItem));
426     ImageItem thumImageItem = CreateImageItem(THUMBNAIL_IMG, pixelFmtRgba_);
427     ASSERT_TRUE(SetValidNclxColor(thumImageItem));
428     refs_.emplace_back(ItemRef {
429         .type = AUXL,
430         .auxType = "",
431         .from = auxlImageItem.id,
432         .to = { thumImageItem.id }
433     });
434     refs_.emplace_back(ItemRef {
435         .type = THMB,
436         .auxType = "",
437         .from = thumImageItem.id,
438         .to = { primaryImageItem.id }
439     });
440     inputImgs_.emplace_back(primaryImageItem);
441     inputImgs_.emplace_back(auxlImageItem);
442     inputImgs_.emplace_back(thumImageItem);
443     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
444     ASSERT_NE(ret, HDF_SUCCESS);
445     ASSERT_EQ(filledLen_, 0);
446 }
447 
448 // [FAIL] auxl image is configured in refs, but not included in inputImgs
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_011, TestSize.Level1)449 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_011, TestSize.Level1)
450 {
451     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
452     ASSERT_TRUE(bufferMgr_ != nullptr);
453     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
454     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
455     ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_);
456     ASSERT_TRUE(SetValidNclxColor(auxlImageItem));
457     refs_.emplace_back(ItemRef {
458         .type = AUXL,
459         .auxType = "",
460         .from = 100,
461         .to = { primaryImageItem.id }
462     });
463     inputImgs_.emplace_back(primaryImageItem);
464     inputImgs_.emplace_back(auxlImageItem);
465     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
466     ASSERT_NE(ret, HDF_SUCCESS);
467     ASSERT_EQ(filledLen_, 0);
468 }
469 
470 // [FAIL] auxl image is related to an image that is not included in inputImgs
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_012, TestSize.Level1)471 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_012, TestSize.Level1)
472 {
473     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
474     ASSERT_TRUE(bufferMgr_ != nullptr);
475     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
476     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
477     ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_);
478     ASSERT_TRUE(SetValidNclxColor(auxlImageItem));
479     refs_.emplace_back(ItemRef {
480         .type = AUXL,
481         .auxType = "",
482         .from = auxlImageItem.id,
483         .to = { 100 }
484     });
485     inputImgs_.emplace_back(primaryImageItem);
486     inputImgs_.emplace_back(auxlImageItem);
487     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
488     ASSERT_NE(ret, HDF_SUCCESS);
489     ASSERT_EQ(filledLen_, 0);
490 }
491 
492 // [FAIL] auxl image is related to more than one images
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_013, TestSize.Level1)493 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_013, TestSize.Level1)
494 {
495     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
496     ASSERT_TRUE(bufferMgr_ != nullptr);
497     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
498     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
499     ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_);
500     ASSERT_TRUE(SetValidNclxColor(auxlImageItem));
501     ImageItem thumImageItem = CreateImageItem(THUMBNAIL_IMG, pixelFmtRgba_);
502     ASSERT_TRUE(SetValidNclxColor(thumImageItem));
503     refs_.emplace_back(ItemRef {
504         .type = AUXL,
505         .auxType = "",
506         .from = auxlImageItem.id,
507         .to = { primaryImageItem.id, thumImageItem.id }
508     });
509     refs_.emplace_back(ItemRef {
510         .type = THMB,
511         .auxType = "",
512         .from = thumImageItem.id,
513         .to = { primaryImageItem.id }
514     });
515     inputImgs_.emplace_back(primaryImageItem);
516     inputImgs_.emplace_back(auxlImageItem);
517     inputImgs_.emplace_back(thumImageItem);
518     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
519     ASSERT_NE(ret, HDF_SUCCESS);
520     ASSERT_EQ(filledLen_, 0);
521 }
522 
523 // [FAIL] userdata meta is not related to primary image
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_014, TestSize.Level1)524 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_014, TestSize.Level1)
525 {
526     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
527     ASSERT_TRUE(bufferMgr_ != nullptr);
528     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
529     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
530     ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_);
531     ASSERT_TRUE(SetValidNclxColor(auxlImageItem));
532     refs_.emplace_back(ItemRef {
533         .type = AUXL,
534         .auxType = "",
535         .from = auxlImageItem.id,
536         .to = { primaryImageItem.id }
537     });
538     inputImgs_.emplace_back(primaryImageItem);
539     inputImgs_.emplace_back(auxlImageItem);
540     MetaItem metaUserData = CreateMetaItem(USER_DATA);
541     refs_.emplace_back(ItemRef {
542         .type = CDSC,
543         .auxType = "",
544         .from = metaUserData.id,
545         .to = { auxlImageItem.id }
546     });
547     inputMetas_.emplace_back(metaUserData);
548     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
549     ASSERT_NE(ret, HDF_SUCCESS);
550     ASSERT_EQ(filledLen_, 0);
551 }
552 
553 // [FAIL] userdata meta is configured in refs, but not included in inputMetas
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_015, TestSize.Level1)554 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_015, TestSize.Level1)
555 {
556     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
557     ASSERT_TRUE(bufferMgr_ != nullptr);
558     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
559     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
560     inputImgs_.emplace_back(primaryImageItem);
561     MetaItem metaUserData = CreateMetaItem(USER_DATA);
562     refs_.emplace_back(ItemRef {
563         .type = CDSC,
564         .auxType = "",
565         .from = metaUserData.id,
566         .to = { primaryImageItem.id }
567     });
568     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
569     ASSERT_NE(ret, HDF_SUCCESS);
570     ASSERT_EQ(filledLen_, 0);
571 }
572 
573 // [FAIL] userdata meta is related to an image that is not included in inputImgs
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_016, TestSize.Level1)574 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_016, TestSize.Level1)
575 {
576     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
577     ASSERT_TRUE(bufferMgr_ != nullptr);
578     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
579     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
580     inputImgs_.emplace_back(primaryImageItem);
581     MetaItem metaUserData = CreateMetaItem(USER_DATA);
582     refs_.emplace_back(ItemRef {
583         .type = CDSC,
584         .auxType = "",
585         .from = metaUserData.id,
586         .to = { 100 }
587     });
588     inputMetas_.emplace_back(metaUserData);
589     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
590     ASSERT_NE(ret, HDF_SUCCESS);
591     ASSERT_EQ(filledLen_, 0);
592 }
593 
594 // [FAIL] userdata meta is related to more than one images
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_017, TestSize.Level1)595 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_017, TestSize.Level1)
596 {
597     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
598     ASSERT_TRUE(bufferMgr_ != nullptr);
599     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
600     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
601     inputImgs_.emplace_back(primaryImageItem);
602     MetaItem metaUserData = CreateMetaItem(USER_DATA);
603     refs_.emplace_back(ItemRef {
604         .type = CDSC,
605         .auxType = "",
606         .from = metaUserData.id,
607         .to = { primaryImageItem.id, 100 }
608     });
609     inputMetas_.emplace_back(metaUserData);
610     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
611     ASSERT_NE(ret, HDF_SUCCESS);
612     ASSERT_EQ(filledLen_, 0);
613 }
614 
615 // [FAIL] output buffer is not properly configured, fd or capacity is invalid
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_018, TestSize.Level1)616 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_018, TestSize.Level1)
617 {
618     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
619     ASSERT_TRUE(bufferMgr_ != nullptr);
620     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
621     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
622     inputImgs_.emplace_back(primaryImageItem);
623     SharedBuffer errOurput = AllocateSharedBuffer(0);
624     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, errOurput, filledLen_);
625     ASSERT_NE(ret, HDF_SUCCESS);
626     ASSERT_EQ(filledLen_, 0);
627 }
628 
629 // [FAIL] output buffer is not properly configured, capacity is too small
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_019, TestSize.Level1)630 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_019, TestSize.Level1)
631 {
632     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
633     ASSERT_TRUE(bufferMgr_ != nullptr);
634     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
635     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
636     inputImgs_.emplace_back(primaryImageItem);
637     size_t smallSize = 128;
638     SharedBuffer errOurput = AllocateSharedBuffer(smallSize);
639     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, errOurput, filledLen_);
640     ASSERT_NE(ret, HDF_SUCCESS);
641     ASSERT_EQ(filledLen_, 0);
642 }
643 
644 // [OK] primary image + gainmap image
645 #ifdef SUPPORT_HEIF
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_020, TestSize.Level1)646 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_020, TestSize.Level1)
647 {
648     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
649     ASSERT_TRUE(bufferMgr_ != nullptr);
650     ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_);
651     ASSERT_TRUE(SetPropeForTmap(tmapImageItem));
652     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_);
653     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
654     ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_);
655     ASSERT_TRUE(SetValidNclxColor(gainMapImageItem));
656     refs_.emplace_back(ItemRef {
657         .type = DIMG,
658         .auxType = "",
659         .from = tmapImageItem.id,
660         .to = { primaryImageItem.id, gainMapImageItem.id }
661     });
662     inputImgs_.emplace_back(tmapImageItem);
663     inputImgs_.emplace_back(primaryImageItem);
664     inputImgs_.emplace_back(gainMapImageItem);
665     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
666     ASSERT_EQ(ret, HDF_SUCCESS);
667     ASSERT_TRUE(filledLen_ > 0);
668 }
669 #endif
670 
671 // [FAIL] Tmap image is configured in refs, but not included in inputImgs
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_021, TestSize.Level1)672 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_021, TestSize.Level1)
673 {
674     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
675     ASSERT_TRUE(bufferMgr_ != nullptr);
676     ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_);
677     ASSERT_TRUE(SetPropeForTmap(tmapImageItem));
678     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_);
679     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
680     ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_);
681     ASSERT_TRUE(SetValidNclxColor(gainMapImageItem));
682     refs_.emplace_back(ItemRef {
683         .type = DIMG,
684         .auxType = "",
685         .from = tmapImageItem.id,
686         .to = { primaryImageItem.id, gainMapImageItem.id }
687     });
688     inputImgs_.emplace_back(primaryImageItem);
689     inputImgs_.emplace_back(gainMapImageItem);
690     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
691     ASSERT_NE(ret, HDF_SUCCESS);
692     ASSERT_EQ(filledLen_, 0);
693 }
694 
695 // [FAIL] Tmap is not related to any gainmap
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_022, TestSize.Level1)696 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_022, TestSize.Level1)
697 {
698     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
699     ASSERT_TRUE(bufferMgr_ != nullptr);
700     ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_);
701     ASSERT_TRUE(SetPropeForTmap(tmapImageItem));
702     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_);
703     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
704     ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_);
705     ASSERT_TRUE(SetValidNclxColor(gainMapImageItem));
706     refs_.emplace_back(ItemRef {
707         .type = DIMG,
708         .auxType = "",
709         .from = tmapImageItem.id,
710         .to = { primaryImageItem.id }
711     });
712     inputImgs_.emplace_back(tmapImageItem);
713     inputImgs_.emplace_back(primaryImageItem);
714     inputImgs_.emplace_back(gainMapImageItem);
715     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
716     ASSERT_NE(ret, HDF_SUCCESS);
717     ASSERT_EQ(filledLen_, 0);
718 }
719 
720 // [FAIL] Tmap is related to two identical images
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_023, TestSize.Level1)721 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_023, TestSize.Level1)
722 {
723     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
724     ASSERT_TRUE(bufferMgr_ != nullptr);
725     ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_);
726     ASSERT_TRUE(SetPropeForTmap(tmapImageItem));
727     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_);
728     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
729     ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_);
730     ASSERT_TRUE(SetValidNclxColor(gainMapImageItem));
731     refs_.emplace_back(ItemRef {
732         .type = DIMG,
733         .auxType = "",
734         .from = tmapImageItem.id,
735         .to = { gainMapImageItem.id, gainMapImageItem.id }
736     });
737     inputImgs_.emplace_back(tmapImageItem);
738     inputImgs_.emplace_back(primaryImageItem);
739     inputImgs_.emplace_back(gainMapImageItem);
740     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
741     ASSERT_NE(ret, HDF_SUCCESS);
742     ASSERT_EQ(filledLen_, 0);
743 }
744 
745 // [FAIL] Tmap is related to images that are not included in inputImgs
HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_024, TestSize.Level1)746 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_024, TestSize.Level1)
747 {
748     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
749     ASSERT_TRUE(bufferMgr_ != nullptr);
750     ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_);
751     ASSERT_TRUE(SetPropeForTmap(tmapImageItem));
752     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_);
753     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
754     ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_);
755     ASSERT_TRUE(SetValidNclxColor(gainMapImageItem));
756     refs_.emplace_back(ItemRef {
757         .type = DIMG,
758         .auxType = "",
759         .from = tmapImageItem.id,
760         .to = { gainMapImageItem.id, 100 }
761     });
762     inputImgs_.emplace_back(tmapImageItem);
763     inputImgs_.emplace_back(primaryImageItem);
764     inputImgs_.emplace_back(gainMapImageItem);
765     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
766     ASSERT_NE(ret, HDF_SUCCESS);
767     ASSERT_EQ(filledLen_, 0);
768 }
769 }