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 // [FAIL] auxl image only
274 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_003, TestSize.Level1)
275 {
276     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
277     ASSERT_TRUE(bufferMgr_ != nullptr);
278     ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_);
279     ASSERT_TRUE(SetValidNclxColor(auxlImageItem));
280     inputImgs_.emplace_back(auxlImageItem);
281     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
282     ASSERT_NE(ret, HDF_SUCCESS);
283     ASSERT_EQ(filledLen_, 0);
284 }
285 
286 // [FAIL] primary image + (image.pixelBuffer == nullptr)
287 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_004, TestSize.Level1)
288 {
289     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
290     ASSERT_TRUE(bufferMgr_ != nullptr);
291     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_, false);
292     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
293     inputImgs_.emplace_back(primaryImageItem);
294     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
295     ASSERT_NE(ret, HDF_SUCCESS);
296     ASSERT_EQ(filledLen_, 0);
297 }
298 
299 // [FAIL] primary image + unsupported pixelFmt in image.pixelBuffer
300 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_005, TestSize.Level1)
301 {
302     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
303     ASSERT_TRUE(bufferMgr_ != nullptr);
304     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false);
305     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
306     inputImgs_.emplace_back(primaryImageItem);
307     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
308     ASSERT_NE(ret, HDF_SUCCESS);
309     ASSERT_EQ(filledLen_, 0);
310 }
311 
312 // [FAIL] primary image + (COLOR_TYPE == NCLX) + COLOR_INFO not configured
313 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_006, TestSize.Level1)
314 {
315     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
316     ASSERT_TRUE(bufferMgr_ != nullptr);
317     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false);
318     ASSERT_TRUE(SetColorTypeOnly(primaryImageItem, NCLX));
319     inputImgs_.emplace_back(primaryImageItem);
320     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
321     ASSERT_NE(ret, HDF_SUCCESS);
322     ASSERT_EQ(filledLen_, 0);
323 }
324 
325 // [FAIL] primary image + (COLOR_TYPE == RICC) + ICC_PROFILE not configured
326 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_007, TestSize.Level1)
327 {
328     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
329     ASSERT_TRUE(bufferMgr_ != nullptr);
330     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false);
331     ASSERT_TRUE(SetColorTypeOnly(primaryImageItem, RICC));
332     inputImgs_.emplace_back(primaryImageItem);
333     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
334     ASSERT_NE(ret, HDF_SUCCESS);
335     ASSERT_EQ(filledLen_, 0);
336 }
337 
338 // [FAIL] primary image + (COLOR_TYPE == RICC) + SharedBuffer that store ICC_PROFILE is not properly filled
339 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_008, TestSize.Level1)
340 {
341     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
342     ASSERT_TRUE(bufferMgr_ != nullptr);
343     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false);
344     ASSERT_TRUE(SetInvalidRiccColor(primaryImageItem));
345     inputImgs_.emplace_back(primaryImageItem);
346     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
347     ASSERT_NE(ret, HDF_SUCCESS);
348     ASSERT_EQ(filledLen_, 0);
349 }
350 
351 // [FAIL] primary image + COLOR_INFO is configured + COLOR_TYPE not configured
352 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_009, TestSize.Level1)
353 {
354     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
355     ASSERT_TRUE(bufferMgr_ != nullptr);
356     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false);
357     ASSERT_TRUE(SetInvalidNclxColor(primaryImageItem));
358     inputImgs_.emplace_back(primaryImageItem);
359     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
360     ASSERT_NE(ret, HDF_SUCCESS);
361     ASSERT_EQ(filledLen_, 0);
362 }
363 
364 // [FAIL] auxl image is not related to primary image
365 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_010, TestSize.Level1)
366 {
367     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
368     ASSERT_TRUE(bufferMgr_ != nullptr);
369     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
370     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
371     ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_);
372     ASSERT_TRUE(SetValidNclxColor(auxlImageItem));
373     ImageItem thumImageItem = CreateImageItem(THUMBNAIL_IMG, pixelFmtRgba_);
374     ASSERT_TRUE(SetValidNclxColor(thumImageItem));
375     refs_.emplace_back(ItemRef {
376         .type = AUXL,
377         .auxType = "",
378         .from = auxlImageItem.id,
379         .to = { thumImageItem.id }
380     });
381     refs_.emplace_back(ItemRef {
382         .type = THMB,
383         .auxType = "",
384         .from = thumImageItem.id,
385         .to = { primaryImageItem.id }
386     });
387     inputImgs_.emplace_back(primaryImageItem);
388     inputImgs_.emplace_back(auxlImageItem);
389     inputImgs_.emplace_back(thumImageItem);
390     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
391     ASSERT_NE(ret, HDF_SUCCESS);
392     ASSERT_EQ(filledLen_, 0);
393 }
394 
395 // [FAIL] auxl image is configured in refs, but not included in inputImgs
396 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_011, TestSize.Level1)
397 {
398     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
399     ASSERT_TRUE(bufferMgr_ != nullptr);
400     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
401     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
402     ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_);
403     ASSERT_TRUE(SetValidNclxColor(auxlImageItem));
404     refs_.emplace_back(ItemRef {
405         .type = AUXL,
406         .auxType = "",
407         .from = 100,
408         .to = { primaryImageItem.id }
409     });
410     inputImgs_.emplace_back(primaryImageItem);
411     inputImgs_.emplace_back(auxlImageItem);
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 related to an image that is not included in inputImgs
418 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_012, 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     refs_.emplace_back(ItemRef {
427         .type = AUXL,
428         .auxType = "",
429         .from = auxlImageItem.id,
430         .to = { 100 }
431     });
432     inputImgs_.emplace_back(primaryImageItem);
433     inputImgs_.emplace_back(auxlImageItem);
434     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
435     ASSERT_NE(ret, HDF_SUCCESS);
436     ASSERT_EQ(filledLen_, 0);
437 }
438 
439 // [FAIL] auxl image is related to more than one images
440 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_013, TestSize.Level1)
441 {
442     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
443     ASSERT_TRUE(bufferMgr_ != nullptr);
444     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
445     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
446     ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_);
447     ASSERT_TRUE(SetValidNclxColor(auxlImageItem));
448     ImageItem thumImageItem = CreateImageItem(THUMBNAIL_IMG, pixelFmtRgba_);
449     ASSERT_TRUE(SetValidNclxColor(thumImageItem));
450     refs_.emplace_back(ItemRef {
451         .type = AUXL,
452         .auxType = "",
453         .from = auxlImageItem.id,
454         .to = { primaryImageItem.id, thumImageItem.id }
455     });
456     refs_.emplace_back(ItemRef {
457         .type = THMB,
458         .auxType = "",
459         .from = thumImageItem.id,
460         .to = { primaryImageItem.id }
461     });
462     inputImgs_.emplace_back(primaryImageItem);
463     inputImgs_.emplace_back(auxlImageItem);
464     inputImgs_.emplace_back(thumImageItem);
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] userdata meta is not related to primary image
471 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_014, 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 = { primaryImageItem.id }
484     });
485     inputImgs_.emplace_back(primaryImageItem);
486     inputImgs_.emplace_back(auxlImageItem);
487     MetaItem metaUserData = CreateMetaItem(USER_DATA);
488     refs_.emplace_back(ItemRef {
489         .type = CDSC,
490         .auxType = "",
491         .from = metaUserData.id,
492         .to = { auxlImageItem.id }
493     });
494     inputMetas_.emplace_back(metaUserData);
495     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
496     ASSERT_NE(ret, HDF_SUCCESS);
497     ASSERT_EQ(filledLen_, 0);
498 }
499 
500 // [FAIL] userdata meta is configured in refs, but not included in inputMetas
501 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_015, TestSize.Level1)
502 {
503     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
504     ASSERT_TRUE(bufferMgr_ != nullptr);
505     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
506     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
507     inputImgs_.emplace_back(primaryImageItem);
508     MetaItem metaUserData = CreateMetaItem(USER_DATA);
509     refs_.emplace_back(ItemRef {
510         .type = CDSC,
511         .auxType = "",
512         .from = metaUserData.id,
513         .to = { primaryImageItem.id }
514     });
515     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
516     ASSERT_NE(ret, HDF_SUCCESS);
517     ASSERT_EQ(filledLen_, 0);
518 }
519 
520 // [FAIL] userdata meta is related to an image that is not included in inputImgs
521 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_016, TestSize.Level1)
522 {
523     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
524     ASSERT_TRUE(bufferMgr_ != nullptr);
525     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
526     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
527     inputImgs_.emplace_back(primaryImageItem);
528     MetaItem metaUserData = CreateMetaItem(USER_DATA);
529     refs_.emplace_back(ItemRef {
530         .type = CDSC,
531         .auxType = "",
532         .from = metaUserData.id,
533         .to = { 100 }
534     });
535     inputMetas_.emplace_back(metaUserData);
536     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
537     ASSERT_NE(ret, HDF_SUCCESS);
538     ASSERT_EQ(filledLen_, 0);
539 }
540 
541 // [FAIL] userdata meta is related to more than one images
542 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_017, TestSize.Level1)
543 {
544     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
545     ASSERT_TRUE(bufferMgr_ != nullptr);
546     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
547     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
548     inputImgs_.emplace_back(primaryImageItem);
549     MetaItem metaUserData = CreateMetaItem(USER_DATA);
550     refs_.emplace_back(ItemRef {
551         .type = CDSC,
552         .auxType = "",
553         .from = metaUserData.id,
554         .to = { primaryImageItem.id, 100 }
555     });
556     inputMetas_.emplace_back(metaUserData);
557     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
558     ASSERT_NE(ret, HDF_SUCCESS);
559     ASSERT_EQ(filledLen_, 0);
560 }
561 
562 // [FAIL] output buffer is not properly configured, fd or capacity is invalid
563 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_018, TestSize.Level1)
564 {
565     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
566     ASSERT_TRUE(bufferMgr_ != nullptr);
567     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
568     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
569     inputImgs_.emplace_back(primaryImageItem);
570     SharedBuffer errOurput = AllocateSharedBuffer(0);
571     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, errOurput, filledLen_);
572     ASSERT_NE(ret, HDF_SUCCESS);
573     ASSERT_EQ(filledLen_, 0);
574 }
575 
576 // [FAIL] output buffer is not properly configured, capacity is too small
577 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_019, TestSize.Level1)
578 {
579     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
580     ASSERT_TRUE(bufferMgr_ != nullptr);
581     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_);
582     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
583     inputImgs_.emplace_back(primaryImageItem);
584     size_t smallSize = 128;
585     SharedBuffer errOurput = AllocateSharedBuffer(smallSize);
586     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, errOurput, filledLen_);
587     ASSERT_NE(ret, HDF_SUCCESS);
588     ASSERT_EQ(filledLen_, 0);
589 }
590 
591 // [FAIL] Tmap image is configured in refs, but not included in inputImgs
592 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_021, TestSize.Level1)
593 {
594     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
595     ASSERT_TRUE(bufferMgr_ != nullptr);
596     ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_);
597     ASSERT_TRUE(SetPropeForTmap(tmapImageItem));
598     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_);
599     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
600     ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_);
601     ASSERT_TRUE(SetValidNclxColor(gainMapImageItem));
602     refs_.emplace_back(ItemRef {
603         .type = DIMG,
604         .auxType = "",
605         .from = tmapImageItem.id,
606         .to = { primaryImageItem.id, gainMapImageItem.id }
607     });
608     inputImgs_.emplace_back(primaryImageItem);
609     inputImgs_.emplace_back(gainMapImageItem);
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] Tmap is not related to any gainmap
616 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_022, TestSize.Level1)
617 {
618     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
619     ASSERT_TRUE(bufferMgr_ != nullptr);
620     ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_);
621     ASSERT_TRUE(SetPropeForTmap(tmapImageItem));
622     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_);
623     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
624     ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_);
625     ASSERT_TRUE(SetValidNclxColor(gainMapImageItem));
626     refs_.emplace_back(ItemRef {
627         .type = DIMG,
628         .auxType = "",
629         .from = tmapImageItem.id,
630         .to = { primaryImageItem.id }
631     });
632     inputImgs_.emplace_back(tmapImageItem);
633     inputImgs_.emplace_back(primaryImageItem);
634     inputImgs_.emplace_back(gainMapImageItem);
635     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
636     ASSERT_NE(ret, HDF_SUCCESS);
637     ASSERT_EQ(filledLen_, 0);
638 }
639 
640 // [FAIL] Tmap is related to two identical images
641 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_023, TestSize.Level1)
642 {
643     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
644     ASSERT_TRUE(bufferMgr_ != nullptr);
645     ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_);
646     ASSERT_TRUE(SetPropeForTmap(tmapImageItem));
647     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_);
648     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
649     ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_);
650     ASSERT_TRUE(SetValidNclxColor(gainMapImageItem));
651     refs_.emplace_back(ItemRef {
652         .type = DIMG,
653         .auxType = "",
654         .from = tmapImageItem.id,
655         .to = { gainMapImageItem.id, gainMapImageItem.id }
656     });
657     inputImgs_.emplace_back(tmapImageItem);
658     inputImgs_.emplace_back(primaryImageItem);
659     inputImgs_.emplace_back(gainMapImageItem);
660     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
661     ASSERT_NE(ret, HDF_SUCCESS);
662     ASSERT_EQ(filledLen_, 0);
663 }
664 
665 // [FAIL] Tmap is related to images that are not included in inputImgs
666 HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_024, TestSize.Level1)
667 {
668     ASSERT_TRUE(hdiHeifEncoder_ != nullptr);
669     ASSERT_TRUE(bufferMgr_ != nullptr);
670     ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_);
671     ASSERT_TRUE(SetPropeForTmap(tmapImageItem));
672     ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_);
673     ASSERT_TRUE(SetValidNclxColor(primaryImageItem));
674     ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_);
675     ASSERT_TRUE(SetValidNclxColor(gainMapImageItem));
676     refs_.emplace_back(ItemRef {
677         .type = DIMG,
678         .auxType = "",
679         .from = tmapImageItem.id,
680         .to = { gainMapImageItem.id, 100 }
681     });
682     inputImgs_.emplace_back(tmapImageItem);
683     inputImgs_.emplace_back(primaryImageItem);
684     inputImgs_.emplace_back(gainMapImageItem);
685     int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_);
686     ASSERT_NE(ret, HDF_SUCCESS);
687     ASSERT_EQ(filledLen_, 0);
688 }
689 }