• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "HeifDecoderImpl.h"
17 
18 #ifdef HEIF_HW_DECODE_ENABLE
19 #include "ffrt.h"
20 #include "image_fwk_ext_manager.h"
21 #include "image_func_timer.h"
22 #include "image_system_properties.h"
23 #include "image_trace.h"
24 #include "image_utils.h"
25 #include "image_log.h"
26 #include "media_errors.h"
27 
28 #include "hardware/heif_hw_decoder.h"
29 #include "heif_impl/hevc_sw_decode_param.h"
30 
31 #ifdef __cplusplus
32 extern "C" {
33 #endif
34 #include "libswscale/swscale.h"
35 #include "libavutil/imgutils.h"
36 #include "libavcodec/avcodec.h"
37 #ifdef __cplusplus
38 }
39 #endif
40 
41 #include <cmath>
42 #include <sstream>
43 
44 #undef LOG_DOMAIN
45 #define LOG_DOMAIN LOG_TAG_DOMAIN_ID_PLUGIN
46 
47 #undef LOG_TAG
48 #define LOG_TAG "HeifDecoderImpl"
49 
50 namespace OHOS {
51 namespace ImagePlugin {
52 using namespace Media;
53 
54 const static int LUMA_8_BIT = 8;
55 const static int LUMA_10_BIT = 10;
56 const static int DEGREE_360 = 360;
57 const static int CHUNK_HEAD_OFFSET_1 = 1;
58 const static int CHUNK_HEAD_OFFSET_2 = 2;
59 const static int CHUNK_HEAD_OFFSET_3 = 3;
60 const static int CHUNK_HEAD_SHIFT_8 = 8;
61 const static int CHUNK_HEAD_SHIFT_16 = 16;
62 const static int CHUNK_HEAD_SHIFT_24 = 24;
63 const static int CHUNK_HEAD_SIZE = 4;
64 const static int PIXEL_OFFSET_0 = 0;
65 const static int PIXEL_OFFSET_1 = 1;
66 const static int PIXEL_OFFSET_2 = 2;
67 const static int PIXEL_OFFSET_3 = 3;
68 const static int PIXEL_SIZE_4 = 4;
69 const static int MAX_ALPHA = 255;
70 
71 const static int GRID_NUM_2 = 2;
72 const static uint32_t PLANE_COUNT_TWO = 2;
73 const static uint32_t HEIF_HARDWARE_TILE_MIN_DIM = 128;
74 const static uint32_t HEIF_HARDWARE_TILE_MAX_DIM = 4096;
75 const static uint32_t HEIF_HARDWARE_DISPLAY_MIN_DIM = 128;
76 const static size_t MAX_INPUT_BUFFER_SIZE = 5 * 1024 * 1024;
77 
78 const static uint16_t BT2020_PRIMARIES = 9;
79 const static int BIT_SHIFT_16BITS = 16;
80 
81 struct PixelFormatConvertParam {
82     uint8_t *data;
83     uint32_t width;
84     uint32_t height;
85     uint32_t stride;
86     uint8_t colorRangeFlag;
87     OH_NativeBuffer_Planes *planesInfo;
88     AVPixelFormat format;
89 };
90 
91 const std::map<AuxiliaryPictureType, std::string> HEIF_AUXTTYPE_ID_MAP = {
92     {AuxiliaryPictureType::GAINMAP, HEIF_AUXTTYPE_ID_GAINMAP},
93     {AuxiliaryPictureType::DEPTH_MAP, HEIF_AUXTTYPE_ID_DEPTH_MAP},
94     {AuxiliaryPictureType::UNREFOCUS_MAP, HEIF_AUXTTYPE_ID_UNREFOCUS_MAP},
95     {AuxiliaryPictureType::LINEAR_MAP, HEIF_AUXTTYPE_ID_LINEAR_MAP},
96     {AuxiliaryPictureType::FRAGMENT_MAP, HEIF_AUXTTYPE_ID_FRAGMENT_MAP}
97 };
98 
FillFrameInfoForPixelConvert(AVFrame * frame,PixelFormatConvertParam & param)99 static bool FillFrameInfoForPixelConvert(AVFrame *frame, PixelFormatConvertParam &param)
100 {
101     if (param.format == AV_PIX_FMT_NV12 || param.format == AV_PIX_FMT_NV21 || param.format == AV_PIX_FMT_P010) {
102         if (param.planesInfo == nullptr || param.planesInfo->planeCount < PLANE_COUNT_TWO) {
103             IMAGE_LOGE("planesInfo is invalid for yuv buffer");
104             return false;
105         }
106         const OH_NativeBuffer_Plane &planeY = param.planesInfo->planes[0];
107         const OH_NativeBuffer_Plane &planeUV = param.planesInfo->planes[param.format == AV_PIX_FMT_NV21 ? 2 : 1];
108         IMAGE_LOGI("planeY offset: %{public}llu, columnStride: %{public}u, rowStride: %{public}u,"
109                    " planeUV offset: %{public}llu, columnStride: %{public}u, rowStride: %{public}u",
110                    planeY.offset, planeY.columnStride, planeY.rowStride,
111                    planeUV.offset, planeUV.columnStride, planeUV.rowStride);
112         frame->data[0] = param.data + planeY.offset;
113         frame->data[1] = param.data + planeUV.offset;
114         frame->linesize[0] = static_cast<int>(planeY.columnStride);
115         frame->linesize[1] = static_cast<int>(planeUV.columnStride);
116     } else {
117         IMAGE_LOGI("rgb stride: %{public}d", param.stride);
118         frame->data[0] = param.data;
119         frame->linesize[0] = static_cast<int>(param.stride);
120     }
121     return true;
122 }
123 
ConvertPixelFormat(PixelFormatConvertParam & srcParam,PixelFormatConvertParam & dstParam)124 static bool ConvertPixelFormat(PixelFormatConvertParam &srcParam, PixelFormatConvertParam &dstParam)
125 {
126     ImageTrace trace("ConvertPixelFormat %d %d", srcParam.format, dstParam.format);
127     IMAGE_LOGD("ConvertPixelFormat %{public}d %{public}d", srcParam.format, dstParam.format);
128     bool res = false;
129     AVFrame *srcFrame = av_frame_alloc();
130     AVFrame *dstFrame = av_frame_alloc();
131     SwsContext *ctx = sws_getContext(static_cast<int>(srcParam.width), static_cast<int>(srcParam.height),
132                                      srcParam.format,
133                                      static_cast<int>(dstParam.width), static_cast<int>(dstParam.height),
134                                      dstParam.format,
135                                      SWS_BICUBIC, nullptr, nullptr, nullptr);
136 
137     //if need applu colorspace in scale, change defult table;
138     auto srcColorTable = sws_getCoefficients(SWS_CS_DEFAULT);
139     auto dstColorTable = sws_getCoefficients(SWS_CS_DEFAULT);
140     sws_setColorspaceDetails(ctx, srcColorTable,
141                              srcParam.colorRangeFlag,
142                              dstColorTable, 0,
143                              0, 1 << BIT_SHIFT_16BITS, 1 << BIT_SHIFT_16BITS);
144     if (srcFrame != nullptr && dstFrame != nullptr && ctx != nullptr) {
145         res = FillFrameInfoForPixelConvert(srcFrame, srcParam)
146                 && FillFrameInfoForPixelConvert(dstFrame, dstParam)
147                 && sws_scale(ctx, srcFrame->data, srcFrame->linesize, 0,
148                              static_cast<int>(srcParam.height), dstFrame->data, dstFrame->linesize);
149     }
150 
151     av_frame_free(&srcFrame);
152     av_frame_free(&dstFrame);
153     sws_freeContext(ctx);
154     return res;
155 }
156 
GraphicPixFmt2AvPixFmtForYuv(GraphicPixelFormat pixelFormat)157 static AVPixelFormat GraphicPixFmt2AvPixFmtForYuv(GraphicPixelFormat pixelFormat)
158 {
159     AVPixelFormat res = AV_PIX_FMT_NV12;
160     switch (pixelFormat) {
161         case GRAPHIC_PIXEL_FMT_YCBCR_420_SP:
162             res = AV_PIX_FMT_NV12;
163             break;
164         case GRAPHIC_PIXEL_FMT_YCRCB_420_SP:
165             res = AV_PIX_FMT_NV21;
166             break;
167         case GRAPHIC_PIXEL_FMT_YCBCR_P010:
168             res = AV_PIX_FMT_P010;
169             break;
170         default:
171             break;
172     }
173     return res;
174 }
175 
PixFmt2AvPixFmtForOutput(PixelFormat pixelFormat)176 static AVPixelFormat PixFmt2AvPixFmtForOutput(PixelFormat pixelFormat)
177 {
178     AVPixelFormat res = AV_PIX_FMT_RGBA;
179     switch (pixelFormat) {
180         case PixelFormat::RGBA_8888:
181             res = AV_PIX_FMT_RGBA;
182             break;
183         case PixelFormat::BGRA_8888:
184             res = AV_PIX_FMT_BGRA;
185             break;
186         case PixelFormat::RGB_565:
187             res = AV_PIX_FMT_RGB565;
188             break;
189         case PixelFormat::NV12:
190             res = AV_PIX_FMT_NV12;
191             break;
192         case PixelFormat::NV21:
193             res = AV_PIX_FMT_NV21;
194             break;
195         case PixelFormat::RGBA_1010102:
196             res = AV_PIX_FMT_X2BGR10;
197             break;
198         default:
199             break;
200     }
201     return res;
202 }
203 
204 // LCOV_EXCL_START
SkHeifColorFormat2PixelFormat(SkHeifColorFormat format)205 static PixelFormat SkHeifColorFormat2PixelFormat(SkHeifColorFormat format)
206 {
207     PixelFormat res = PixelFormat::UNKNOWN;
208     switch (format) {
209         case kHeifColorFormat_RGB565:
210             res = PixelFormat::RGB_565;
211             break;
212         case kHeifColorFormat_RGBA_8888:
213             res = PixelFormat::RGBA_8888;
214             break;
215         case kHeifColorFormat_BGRA_8888:
216             res = PixelFormat::BGRA_8888;
217             break;
218         case kHeifColorFormat_NV12:
219             res = PixelFormat::NV12;
220             break;
221         case kHeifColorFormat_NV21:
222             res = PixelFormat::NV21;
223             break;
224         case kHeifColorFormat_RGBA_1010102:
225             res = PixelFormat::RGBA_1010102;
226             break;
227         case kHeifColorFormat_P010_NV12:
228             res = PixelFormat::YCBCR_P010;
229             break;
230         case kHeifColorFormat_P010_NV21:
231             res = PixelFormat::YCRCB_P010;
232             break;
233         default:
234             IMAGE_LOGE("Unsupported dst pixel format: %{public}d", format);
235             break;
236     }
237     return res;
238 }
239 // LCOV_EXCL_STOP
240 
HeifDecoderImpl()241 HeifDecoderImpl::HeifDecoderImpl()
242     : outPixelFormat_(PixelFormat::RGBA_8888),
243     dstMemory_(nullptr), dstRowStride_(0), dstHwBuffer_(nullptr),
244     gainmapDstMemory_(nullptr), gainmapDstRowStride_(0),
245     auxiliaryDstMemory_(nullptr), auxiliaryDstRowStride_(0),
246     auxiliaryDstMemorySize_(0) {}
247 
~HeifDecoderImpl()248 HeifDecoderImpl::~HeifDecoderImpl()
249 {
250     if (srcMemory_ != nullptr) {
251         delete[] srcMemory_;
252     }
253 }
254 
init(HeifStream * stream,HeifFrameInfo * frameInfo)255 bool HeifDecoderImpl::init(HeifStream *stream, HeifFrameInfo *frameInfo)
256 {
257     ImageTrace trace("HeifDecoderImpl::init");
258     if (stream == nullptr) {
259         return false;
260     }
261 
262     size_t fileLength = stream->getLength();
263     if (srcMemory_ == nullptr) {
264         if (fileLength == 0) {
265             IMAGE_LOGE("file size is 0");
266             return false;
267         }
268         srcMemory_ = new uint8_t[fileLength];
269         if (srcMemory_ == nullptr) {
270             return false;
271         }
272         stream->read(srcMemory_, fileLength);
273     }
274 
275     heif_error err = HeifParser::MakeFromMemory(srcMemory_, fileLength, false, &parser_);
276     if (parser_ == nullptr || err != heif_error_ok) {
277         IMAGE_LOGE("make heif parser failed, err: %{public}d", err);
278         return false;
279     }
280     primaryImage_ = parser_->GetPrimaryImage();
281     if (primaryImage_ == nullptr) {
282         IMAGE_LOGE("heif primary image is null");
283         return false;
284     }
285     gainmapImage_ = parser_->GetGainmapImage();
286     std::shared_ptr<HeifImage> tmapImage = parser_->GetTmapImage();
287     if (tmapImage != nullptr) {
288         InitFrameInfo(&tmapInfo_, tmapImage);
289     }
290     return Reinit(frameInfo);
291 }
292 
CheckAuxiliaryMap(AuxiliaryPictureType type)293 bool HeifDecoderImpl::CheckAuxiliaryMap(AuxiliaryPictureType type)
294 {
295     if (parser_ == nullptr) {
296         IMAGE_LOGE("Heif parser is nullptr.");
297         return false;
298     }
299 
300     auto iter = HEIF_AUXTTYPE_ID_MAP.find(type);
301     switch (type) {
302         case AuxiliaryPictureType::GAINMAP:
303             auxiliaryImage_ = parser_->GetGainmapImage();
304             break;
305         case AuxiliaryPictureType::DEPTH_MAP:
306         case AuxiliaryPictureType::UNREFOCUS_MAP:
307         case AuxiliaryPictureType::LINEAR_MAP:
308         case AuxiliaryPictureType::FRAGMENT_MAP:
309             auxiliaryImage_ = parser_->GetAuxiliaryMapImage(iter->second);
310             break;
311         default:
312             auxiliaryImage_ = nullptr;
313             IMAGE_LOGE("Invalid AuxiliaryPictureType: %{public}d", type);
314             break;
315     }
316 
317     if (auxiliaryImage_ == nullptr) {
318         IMAGE_LOGE("Auxiliary map type that does not exist");
319         return false;
320     }
321 
322     return true;
323 }
324 
setAuxiliaryMap(AuxiliaryPictureType type)325 bool HeifDecoderImpl::setAuxiliaryMap(AuxiliaryPictureType type)
326 {
327     if (auxiliaryImage_ == nullptr && !CheckAuxiliaryMap(type)) {
328         IMAGE_LOGE("make heif parser failed");
329         return false;
330     }
331 
332     InitFrameInfo(&auxiliaryImageInfo_, auxiliaryImage_);
333     InitGridInfo(auxiliaryImage_, auxiliaryGridInfo_);
334     return true;
335 }
336 
Reinit(HeifFrameInfo * frameInfo)337 bool HeifDecoderImpl::Reinit(HeifFrameInfo *frameInfo)
338 {
339     InitFrameInfo(&imageInfo_, primaryImage_);
340     InitGridInfo(primaryImage_, gridInfo_);
341     if (gainmapImage_ != nullptr) {
342         InitFrameInfo(&gainmapImageInfo_, gainmapImage_);
343         InitGridInfo(gainmapImage_, gainmapGridInfo_);
344     }
345     if (frameInfo != nullptr) {
346         *frameInfo = imageInfo_;
347     }
348     return true;
349 }
350 
InitFrameInfo(HeifFrameInfo * info,const std::shared_ptr<HeifImage> & image)351 void HeifDecoderImpl::InitFrameInfo(HeifFrameInfo *info, const std::shared_ptr<HeifImage> &image)
352 {
353     if (info == nullptr || image == nullptr) {
354         IMAGE_LOGE("InitFrameInfo info or image is null");
355         return;
356     }
357     info->mWidth = image->GetOriginalWidth();
358     info->mHeight = image->GetOriginalHeight();
359     info->mRotationAngle = (DEGREE_360 - image->GetRotateDegrees()) % DEGREE_360;
360     info->mBytesPerPixel = static_cast<uint32_t>(ImageUtils::GetPixelBytes(outPixelFormat_));
361     info->mDurationUs = 0;
362     SetColorSpaceInfo(info, image);
363     if (info->mIccData.empty() && !info->hasNclxColor && (parser_->GetItemType(image->GetItemId())== "grid")) {
364         std::vector<std::shared_ptr<HeifImage>> tileImages;
365         parser_->GetTileImages(image->GetItemId(), tileImages);
366         if (!tileImages.empty()) {
367             SetColorSpaceInfo(info, tileImages[0]);
368         }
369     }
370 }
371 
372 // LCOV_EXCL_START
SetColorSpaceInfo(HeifFrameInfo * info,const std::shared_ptr<HeifImage> & image)373 void HeifDecoderImpl::SetColorSpaceInfo(HeifFrameInfo* info, const std::shared_ptr<HeifImage>& image)
374 {
375     auto &iccProfile = image->GetRawColorProfile();
376     size_t iccSize = iccProfile != nullptr ? iccProfile->GetData().size() : 0;
377     if (iccSize > 0) {
378         auto iccProfileData = iccProfile->GetData().data();
379         info->mIccData.assign(iccProfileData, iccProfileData + iccSize);
380     } else {
381         info->mIccData.clear();
382     }
383     auto& nclx = image->GetNclxColorProfile();
384     if (nclx != nullptr) {
385         info->hasNclxColor = true;
386         info->nclxColor.colorPrimaries = nclx->GetColorPrimaries();
387         info->nclxColor.transferCharacteristics = nclx->GetTransferCharacteristics();
388         info->nclxColor.matrixCoefficients = nclx->GetMatrixCoefficients();
389         info->nclxColor.fullRangeFlag = nclx->GetFullRangeFlag();
390     } else {
391         info->hasNclxColor = false;
392     }
393 }
394 // LCOV_EXCL_STOP
395 
InitGridInfo(const std::shared_ptr<HeifImage> & image,GridInfo & gridInfo)396 void HeifDecoderImpl::InitGridInfo(const std::shared_ptr<HeifImage> &image, GridInfo &gridInfo)
397 {
398     if (!image) {
399         IMAGE_LOGE("InitGridInfo image is null");
400         return;
401     }
402     gridInfo.displayWidth = image->GetOriginalWidth();
403     gridInfo.displayHeight = image->GetOriginalHeight();
404     gridInfo.colorRangeFlag = image->GetColorRangeFlag();
405     GetTileSize(image, gridInfo);
406     GetRowColNum(gridInfo);
407 }
408 
GetTileSize(const std::shared_ptr<HeifImage> & image,GridInfo & gridInfo)409 void HeifDecoderImpl::GetTileSize(const std::shared_ptr<HeifImage> &image, GridInfo &gridInfo)
410 {
411     if (!image) {
412         IMAGE_LOGE("GetTileSize image is null");
413         return;
414     }
415 
416     std::string imageType = parser_->GetItemType(image->GetItemId());
417     if (imageType == "hvc1") {
418         gridInfo.tileWidth = image->GetOriginalWidth();
419         gridInfo.tileHeight = image->GetOriginalHeight();
420         return;
421     }
422     if (imageType == "iden") {
423         std::shared_ptr<HeifImage> idenImage;
424         parser_->GetIdenImage(image->GetItemId(), idenImage);
425         if (idenImage != nullptr && idenImage != image) {
426             GetTileSize(idenImage, gridInfo);
427         }
428         return;
429     }
430     if (imageType != "grid") {
431         IMAGE_LOGE("GetTileSize unsupported image type: %{public}s", imageType.c_str());
432         return;
433     }
434     std::vector<std::shared_ptr<HeifImage>> tileImages;
435     parser_->GetTileImages(image->GetItemId(), tileImages);
436     if (tileImages.empty() || tileImages[0] == nullptr) {
437         IMAGE_LOGE("grid image has no tile image");
438         return;
439     }
440     gridInfo.tileWidth = tileImages[0]->GetOriginalWidth();
441     gridInfo.tileHeight = tileImages[0]->GetOriginalHeight();
442 }
443 
GetRowColNum(GridInfo & gridInfo)444 void HeifDecoderImpl::GetRowColNum(GridInfo &gridInfo)
445 {
446     if (gridInfo.tileWidth != 0) {
447         gridInfo.cols = static_cast<size_t>(ceil((double)gridInfo.displayWidth / (double)gridInfo.tileWidth));
448     }
449     if (gridInfo.tileHeight != 0) {
450         gridInfo.rows = static_cast<size_t>(ceil((double)gridInfo.displayHeight / (double)gridInfo.tileHeight));
451     }
452 }
453 
GetInPixelFormat(const std::shared_ptr<HeifImage> & image)454 GraphicPixelFormat HeifDecoderImpl::GetInPixelFormat(const std::shared_ptr<HeifImage> &image)
455 {
456     return (image != nullptr && image->GetLumaBitNum() == LUMA_10_BIT) ?
457             GRAPHIC_PIXEL_FMT_YCBCR_P010 : GRAPHIC_PIXEL_FMT_YCBCR_420_SP;
458 }
459 
getSequenceInfo(HeifFrameInfo * frameInfo,size_t * frameCount)460 bool HeifDecoderImpl::getSequenceInfo(HeifFrameInfo *frameInfo, size_t *frameCount)
461 {
462     // unimplemented
463     return false;
464 }
465 
setOutputColor(SkHeifColorFormat heifColor)466 bool HeifDecoderImpl::setOutputColor(SkHeifColorFormat heifColor)
467 {
468     outPixelFormat_ = SkHeifColorFormat2PixelFormat(heifColor);
469     imageInfo_.mBytesPerPixel = static_cast<uint32_t>(ImageUtils::GetPixelBytes(outPixelFormat_));
470     return outPixelFormat_ != PixelFormat::UNKNOWN;
471 }
472 
IsSupportHardwareDecode(const GridInfo & gridInfo)473 static bool IsSupportHardwareDecode(const GridInfo &gridInfo)
474 {
475     if (!ImageSystemProperties::GetHeifHardwareDecodeEnabled()) {
476         return false;
477     }
478     return gridInfo.tileWidth >= HEIF_HARDWARE_TILE_MIN_DIM &&
479            gridInfo.tileHeight >= HEIF_HARDWARE_TILE_MIN_DIM &&
480            gridInfo.tileWidth <= HEIF_HARDWARE_TILE_MAX_DIM &&
481            gridInfo.tileHeight <= HEIF_HARDWARE_TILE_MAX_DIM &&
482            gridInfo.displayWidth >= HEIF_HARDWARE_DISPLAY_MIN_DIM &&
483            gridInfo.displayHeight >= HEIF_HARDWARE_DISPLAY_MIN_DIM;
484 }
485 
decode(HeifFrameInfo * frameInfo)486 bool HeifDecoderImpl::decode(HeifFrameInfo *frameInfo)
487 {
488     ImageTrace trace("HeifDecoderImpl::decode");
489     if (!IsSupportHardwareDecode(gridInfo_)) {
490         HevcSoftDecodeParam param {
491             gridInfo_, outPixelFormat_,
492             dstMemory_, 0,
493             static_cast<uint32_t>(dstRowStride_), dstHwBuffer_
494         };
495         bool decodeRes = SwDecodeImage(primaryImage_, param, gridInfo_, true);
496         if (!decodeRes) {
497             return false;
498         }
499         SwApplyAlphaImage(primaryImage_, dstMemory_, dstRowStride_);
500         if (dstHwBuffer_ && (dstHwBuffer_->GetUsage() & BUFFER_USAGE_MEM_MMZ_CACHE)) {
501             GSError err = dstHwBuffer_->Map();
502             if (err != GSERROR_OK) {
503                 IMAGE_LOGE("SurfaceBuffer Map failed, GSError=%{public}d", err);
504                 return true;
505             }
506             err = dstHwBuffer_->FlushCache();
507             if (err != GSERROR_OK) {
508                 IMAGE_LOGE("FlushCache failed, GSError=%{public}d", err);
509             }
510         }
511         return true;
512     }
513     sptr<SurfaceBuffer> hwBuffer;
514     bool decodeRes = HwDecodeImage(nullptr, primaryImage_, gridInfo_, &hwBuffer, true);
515     if (!decodeRes) {
516         return false;
517     }
518 
519     bool convertRes = IsDirectYUVDecode() ||
520             ConvertHwBufferPixelFormat(hwBuffer, gridInfo_, dstMemory_, dstRowStride_);
521     if (!convertRes) {
522         return false;
523     }
524     bool hwApplyAlphaImageRes = HwApplyAlphaImage(primaryImage_, dstMemory_, dstRowStride_);
525     if (!hwApplyAlphaImageRes) {
526         SwApplyAlphaImage(primaryImage_, dstMemory_, dstRowStride_);
527     }
528     if (hwBuffer && (hwBuffer->GetUsage() & BUFFER_USAGE_MEM_MMZ_CACHE)) {
529         GSError err = hwBuffer->InvalidateCache();
530         if (err != GSERROR_OK) {
531             IMAGE_LOGE("InvalidateCache failed, GSError=%{public}d", err);
532         }
533     }
534     return true;
535 }
536 
decodeGainmap()537 bool HeifDecoderImpl::decodeGainmap()
538 {
539     ImageTrace trace("HeifDecoderImpl::decodeGainmap");
540     sptr<SurfaceBuffer> hwBuffer;
541     bool decodeRes = HwDecodeImage(nullptr, gainmapImage_, gainmapGridInfo_, &hwBuffer, false);
542     if (!decodeRes) {
543         return false;
544     }
545 
546     bool convertRes = IsDirectYUVDecode() ||
547             ConvertHwBufferPixelFormat(hwBuffer, gainmapGridInfo_, gainmapDstMemory_, gainmapDstRowStride_);
548     if (!convertRes) {
549         return false;
550     }
551     return true;
552 }
553 
decodeAuxiliaryMap()554 bool HeifDecoderImpl::decodeAuxiliaryMap()
555 {
556     ImageTrace trace("HeifDecoderImpl::decodeAuxiliaryMap");
557     if (auxiliaryImage_ != nullptr && parser_ != nullptr &&
558         parser_->GetItemType(auxiliaryImage_->GetItemId()) == "mime") {
559         return HwDecodeMimeImage(auxiliaryImage_);
560     }
561     sptr<SurfaceBuffer> hwBuffer;
562     bool decodeRes = HwDecodeImage(nullptr, auxiliaryImage_, auxiliaryGridInfo_, &hwBuffer, false);
563     if (!decodeRes) {
564         return false;
565     }
566 
567     bool convertRes = IsDirectYUVDecode() ||
568             ConvertHwBufferPixelFormat(hwBuffer, auxiliaryGridInfo_, auxiliaryDstMemory_, auxiliaryDstRowStride_);
569     if (!convertRes) {
570         return false;
571     }
572     return true;
573 }
574 
ReleaseHwDecoder(HeifHardwareDecoder * hwDecoder,bool isReuse)575 void HeifDecoderImpl::ReleaseHwDecoder(HeifHardwareDecoder *hwDecoder, bool isReuse)
576 {
577     if (isReuse || hwDecoder == nullptr) {
578         return;
579     }
580     ffrt::submit([hwDecoder] {
581         ImageTrace trace("delete hwDecoder");
582         delete hwDecoder;
583         }, {}, {});
584 }
585 
HwDecodeImage(HeifHardwareDecoder * hwDecoder,std::shared_ptr<HeifImage> & image,GridInfo & gridInfo,sptr<SurfaceBuffer> * outBuffer,bool isPrimary)586 bool HeifDecoderImpl::HwDecodeImage(HeifHardwareDecoder *hwDecoder,
587                                     std::shared_ptr<HeifImage> &image, GridInfo &gridInfo,
588                                     sptr<SurfaceBuffer> *outBuffer, bool isPrimary)
589 {
590     if (outPixelFormat_ == PixelFormat::UNKNOWN) {
591         IMAGE_LOGE("unknown pixel type: %{public}d", outPixelFormat_);
592         return false;
593     }
594 
595     if (image == nullptr || outBuffer == nullptr) {
596         return false;
597     }
598 
599     bool isReuseHwDecoder = hwDecoder != nullptr;
600     if (!isReuseHwDecoder) {
601         hwDecoder = new (std::nothrow) HeifHardwareDecoder();
602         if (hwDecoder == nullptr) {
603             IMAGE_LOGE("make HeifHardwareDecoder failed");
604             return false;
605         }
606     }
607 
608     std::string imageType = parser_->GetItemType(image->GetItemId());
609     if (imageType == "iden") {
610         bool res = HwDecodeIdenImage(hwDecoder, image, gridInfo, outBuffer, isPrimary);
611         ReleaseHwDecoder(hwDecoder, isReuseHwDecoder);
612         return res;
613     }
614 
615     GraphicPixelFormat inPixelFormat = GetInPixelFormat(image);
616     sptr<SurfaceBuffer> hwBuffer =
617             isPrimary && IsDirectYUVDecode() ? sptr<SurfaceBuffer>(dstHwBuffer_) :
618             hwDecoder->AllocateOutputBuffer(gridInfo.displayWidth, gridInfo.displayHeight, inPixelFormat);
619     if (hwBuffer == nullptr) {
620         IMAGE_LOGE("decode AllocateOutputBuffer return null");
621         ReleaseHwDecoder(hwDecoder, isReuseHwDecoder);
622         return false;
623     }
624     if (IsDirectYUVDecode()) {
625         inPixelFormat = static_cast<GraphicPixelFormat>(hwBuffer->GetFormat());
626     }
627 
628     bool res = false;
629     IMAGE_LOGI("HeifDecoderImpl::DecodeImage width: %{public}d, height: %{public}d, imageType: %{public}s,"
630         "inPixelFormat: %{public}d", gridInfo.displayWidth, gridInfo.displayHeight, imageType.c_str(), inPixelFormat);
631     if (imageType == "grid") {
632         gridInfo.enableGrid = true;
633         res = HwDecodeGrids(hwDecoder, image, gridInfo, hwBuffer);
634     } else if (imageType == "hvc1") {
635         gridInfo.enableGrid = false;
636         res = HwDecodeSingleImage(hwDecoder, image, gridInfo, hwBuffer);
637     }
638     if (res) {
639         *outBuffer = hwBuffer;
640     }
641     ReleaseHwDecoder(hwDecoder, isReuseHwDecoder);
642     return res;
643 }
644 
PreparePackedInput(HeifHardwareDecoder * hwDecoder,std::vector<std::shared_ptr<HeifImage>> tileImages,std::vector<std::vector<uint8_t>> & packedInput,size_t gridCount)645 void HeifDecoderImpl::PreparePackedInput(HeifHardwareDecoder *hwDecoder,
646     std::vector<std::shared_ptr<HeifImage>> tileImages,
647     std::vector<std::vector<uint8_t>> &packedInput, size_t gridCount)
648 {
649     if (hwDecoder->IsPackedInputSupported()) {
650         size_t gridLength = 0;
651         size_t inputIndex = 0;
652         packedInput.resize(GRID_NUM_2);
653         for (size_t index = 0; index < gridCount; ++index) {
654             std::shared_ptr<HeifImage> &tileImage = tileImages[index];
655             std::shared_ptr<HeifImage> nextTileImage;
656             if (index == 0) {
657                 // get hvcc header
658                 parser_->GetItemData(tileImage->GetItemId(), &packedInput[inputIndex], heif_only_header);
659                 ProcessChunkHead(packedInput[inputIndex].data(), packedInput[inputIndex].size());
660                 ++inputIndex;
661             }
662             if (packedInput[inputIndex].size() + gridLength >= MAX_INPUT_BUFFER_SIZE) {
663                 ProcessChunkHead(packedInput[inputIndex].data(), packedInput[inputIndex].size());
664                 ++inputIndex;
665                 packedInput.emplace_back(std::vector<uint8_t>());
666             }
667             parser_->GetItemData(tileImage->GetItemId(), &packedInput[inputIndex], heif_no_header);
668             gridLength = 0;
669             if (index + 1 != gridCount) {
670                 nextTileImage = tileImages[index + 1];
671                 parser_->GetGridLength(nextTileImage->GetItemId(), gridLength);
672             }
673         }
674         ProcessChunkHead(packedInput[inputIndex].data(), packedInput[inputIndex].size());
675     } else {
676         packedInput.resize(gridCount + 1);
677         for (size_t index = 0; index < gridCount; ++index) {
678             std::shared_ptr<HeifImage> &tileImage = tileImages[index];
679             if (index == 0) {
680                 // get hvcc header
681                 parser_->GetItemData(tileImage->GetItemId(), &packedInput[index], heif_only_header);
682                 ProcessChunkHead(packedInput[index].data(), packedInput[index].size());
683             }
684             parser_->GetItemData(tileImage->GetItemId(), &packedInput[index + 1], heif_no_header);
685             ProcessChunkHead(packedInput[index + 1].data(), packedInput[index + 1].size());
686         }
687     }
688 }
689 
HwDecodeGrids(HeifHardwareDecoder * hwDecoder,std::shared_ptr<HeifImage> & image,GridInfo & gridInfo,sptr<SurfaceBuffer> & hwBuffer)690 bool HeifDecoderImpl::HwDecodeGrids(HeifHardwareDecoder *hwDecoder, std::shared_ptr<HeifImage> &image,
691     GridInfo &gridInfo, sptr<SurfaceBuffer> &hwBuffer)
692 {
693     if (hwDecoder == nullptr || image == nullptr) {
694         IMAGE_LOGE("HeifDecoderImpl::DecodeGrids hwDecoder or image is nullptr");
695         return false;
696     }
697     std::vector<std::shared_ptr<HeifImage>> tileImages;
698     parser_->GetTileImages(image->GetItemId(), tileImages);
699     if (tileImages.empty()) {
700         IMAGE_LOGE("grid image has no tile image");
701         return false;
702     }
703     size_t gridCount = tileImages.size();
704     std::vector<std::vector<uint8_t>> packedInput;
705     PreparePackedInput(hwDecoder, tileImages, packedInput, gridCount);
706 
707     uint32_t err = hwDecoder->DoDecode(gridInfo, packedInput, hwBuffer);
708     if (err != SUCCESS) {
709         IMAGE_LOGE("heif hw decoder return error: %{public}d, width: %{public}d, height: %{public}d,"
710                    " imageType: grid, inPixelFormat: %{public}d, colNum: %{public}d, rowNum: %{public}d,"
711                    " tileWidth: %{public}d, tileHeight: %{public}d, hvccLen: %{public}zu",
712                    err, gridInfo.displayWidth, gridInfo.displayHeight,
713                    hwBuffer->GetFormat(), gridInfo.cols, gridInfo.rows,
714                    gridInfo.tileWidth, gridInfo.tileHeight, packedInput[0].size());
715         SetHardwareDecodeErrMsg(gridInfo.tileWidth, gridInfo.tileHeight);
716         return false;
717     }
718     return true;
719 }
720 
HwDecodeIdenImage(HeifHardwareDecoder * hwDecoder,std::shared_ptr<HeifImage> & image,GridInfo & gridInfo,sptr<SurfaceBuffer> * outBuffer,bool isPrimary)721 bool HeifDecoderImpl::HwDecodeIdenImage(HeifHardwareDecoder *hwDecoder,
722                                         std::shared_ptr<HeifImage> &image, GridInfo &gridInfo,
723                                         sptr<SurfaceBuffer> *outBuffer, bool isPrimary)
724 {
725     if (!image) {
726         return false;
727     }
728     std::shared_ptr<HeifImage> idenImage;
729     parser_->GetIdenImage(image->GetItemId(), idenImage);
730     if (idenImage == nullptr || idenImage == image) {
731         IMAGE_LOGE("invalid iden image");
732         return false;
733     }
734     return HwDecodeImage(hwDecoder, idenImage, gridInfo, outBuffer, isPrimary);
735 }
736 
HwDecodeSingleImage(HeifHardwareDecoder * hwDecoder,std::shared_ptr<HeifImage> & image,GridInfo & gridInfo,sptr<SurfaceBuffer> & hwBuffer)737 bool HeifDecoderImpl::HwDecodeSingleImage(HeifHardwareDecoder *hwDecoder,
738                                           std::shared_ptr<HeifImage> &image,
739                                           GridInfo &gridInfo, sptr<SurfaceBuffer> &hwBuffer)
740 {
741     if (hwDecoder == nullptr || image == nullptr) {
742         IMAGE_LOGE("HeifDecoderImpl::DecodeSingleImage hwDecoder or image is nullptr");
743         return false;
744     }
745     std::vector<std::vector<uint8_t>> inputs(GRID_NUM_2);
746 
747     parser_->GetItemData(image->GetItemId(), &inputs[0], heif_only_header);
748     ProcessChunkHead(inputs[0].data(), inputs[0].size());
749 
750     parser_->GetItemData(image->GetItemId(), &inputs[1], heif_no_header);
751     ProcessChunkHead(inputs[1].data(), inputs[1].size());
752 
753     uint32_t err = hwDecoder->DoDecode(gridInfo, inputs, hwBuffer);
754     if (err != SUCCESS) {
755         IMAGE_LOGE("heif hw decoder return error: %{public}d, width: %{public}d, height: %{public}d,"
756                    " imageType: hvc1, inPixelFormat: %{public}d, colNum: %{public}d, rowNum: %{public}d,"
757                    " tileWidth: %{public}d, tileHeight: %{public}d, hvccLen: %{public}zu, dataLen: %{public}zu",
758                    err, gridInfo.displayWidth, gridInfo.displayHeight,
759                    hwBuffer->GetFormat(), gridInfo.cols, gridInfo.rows,
760                    gridInfo.tileWidth, gridInfo.tileHeight, inputs[0].size(), inputs[1].size());
761         SetHardwareDecodeErrMsg(gridInfo.tileWidth, gridInfo.tileHeight);
762         return false;
763     }
764     return true;
765 }
766 
HwDecodeMimeImage(std::shared_ptr<HeifImage> & image)767 bool HeifDecoderImpl::HwDecodeMimeImage(std::shared_ptr<HeifImage> &image)
768 {
769     if (image == nullptr) {
770         IMAGE_LOGE("HeifDecoderImpl::DecodeSingleImage image is nullptr");
771         return false;
772     }
773     std::vector<uint8_t> inputs;
774     parser_->GetItemData(image->GetItemId(), &inputs, heif_only_header);
775     ProcessChunkHead(inputs.data(), inputs.size());
776 
777     if (auxiliaryDstMemory_ == nullptr || auxiliaryDstMemorySize_ == 0 || inputs.size() == 0) {
778         IMAGE_LOGE("%{public}s: params fail auxiliaryDstMemorySize_ is %{public}zu, input size is %{public}zu",
779             __func__, auxiliaryDstMemorySize_, inputs.size());
780         return false;
781     }
782     if (memcpy_s(auxiliaryDstMemory_, auxiliaryDstMemorySize_, inputs.data(), inputs.size()) != EOK) {
783         IMAGE_LOGE("%{public}s: memcpy failed, auxiliaryDstMemorySize_ is %{public}zu, input size is %{public}ld",
784             __func__, auxiliaryDstMemorySize_, inputs.size());
785         return false;
786     }
787     return true;
788 }
789 
SwDecodeImage(std::shared_ptr<HeifImage> & image,HevcSoftDecodeParam & param,GridInfo & gridInfo,bool isPrimary)790 bool HeifDecoderImpl::SwDecodeImage(std::shared_ptr<HeifImage> &image, HevcSoftDecodeParam &param,
791                                     GridInfo &gridInfo, bool isPrimary)
792 {
793     ImageFuncTimer imageFuncTime("HeifDecoderImpl::%s, desiredpixelformat: %d", __func__, outPixelFormat_);
794     if (outPixelFormat_ == PixelFormat::UNKNOWN) {
795         IMAGE_LOGE("unknown pixel type: %{public}d", outPixelFormat_);
796         return false;
797     }
798     if (image == nullptr) {
799         return false;
800     }
801 
802     std::string imageType = parser_->GetItemType(image->GetItemId());
803     if (imageType == "iden") {
804         return SwDecodeIdenImage(image, param, gridInfo, isPrimary);
805     }
806 
807     static ImageFwkExtManager imageFwkExtManager;
808     bool res = false;
809     if (imageType == "grid") {
810         param.gridInfo.enableGrid = true;
811         gridInfo.enableGrid = true;
812         res = SwDecodeGrids(imageFwkExtManager, image, param);
813     } else if (imageType == "hvc1") {
814         param.gridInfo.enableGrid = false;
815         gridInfo.enableGrid = false;
816         res = SwDecodeSingleImage(imageFwkExtManager, image, param);
817     }
818     return res;
819 }
820 
SwDecodeGrids(ImageFwkExtManager & extManager,std::shared_ptr<HeifImage> & image,HevcSoftDecodeParam & param)821 bool HeifDecoderImpl::SwDecodeGrids(ImageFwkExtManager &extManager,
822                                     std::shared_ptr<HeifImage> &image, HevcSoftDecodeParam &param)
823 {
824     if (extManager.doHardWareEncodeFunc_ == nullptr && !extManager.LoadImageFwkExtNativeSo()) {
825         return false;
826     }
827     if (param.dstBuffer == nullptr || param.dstStride == 0) {
828         return false;
829     }
830     std::vector<std::shared_ptr<HeifImage>> tileImages;
831     parser_->GetTileImages(image->GetItemId(), tileImages);
832     if (tileImages.empty()) {
833         IMAGE_LOGE("grid image has no tile image");
834         return false;
835     }
836     size_t numGrid = tileImages.size();
837     std::vector<std::vector<uint8_t>> inputs(numGrid);
838 
839     for (size_t index = 0; index < numGrid; ++index) {
840         std::shared_ptr<HeifImage> &tileImage = tileImages[index];
841         parser_->GetItemData(tileImage->GetItemId(),
842                              &inputs[index], index == 0 ? heif_header_data : heif_no_header);
843         ProcessChunkHead(inputs[index].data(), inputs[index].size());
844     }
845 
846     int32_t retCode = extManager.hevcSoftwareDecodeFunc_(inputs, param);
847     if (retCode != 0) {
848         IMAGE_LOGE("SwDecodeGrids decode failed: %{public}d", retCode);
849         return false;
850     }
851     return true;
852 }
853 
SwDecodeIdenImage(std::shared_ptr<HeifImage> & image,HevcSoftDecodeParam & param,GridInfo & gridInfo,bool isPrimary)854 bool HeifDecoderImpl::SwDecodeIdenImage(std::shared_ptr<HeifImage> &image,
855                                         HevcSoftDecodeParam &param, GridInfo &gridInfo, bool isPrimary)
856 {
857     if (!image) {
858         return false;
859     }
860     std::shared_ptr<HeifImage> idenImage;
861     parser_->GetIdenImage(image->GetItemId(), idenImage);
862     if (idenImage == nullptr || idenImage == image) {
863         IMAGE_LOGE("invalid iden image");
864         return false;
865     }
866     return SwDecodeImage(idenImage, param, gridInfo, isPrimary);
867 }
868 
SwDecodeSingleImage(ImageFwkExtManager & extManager,std::shared_ptr<HeifImage> & image,HevcSoftDecodeParam & param)869 bool HeifDecoderImpl::SwDecodeSingleImage(ImageFwkExtManager &extManager,
870                                           std::shared_ptr<HeifImage> &image, HevcSoftDecodeParam &param)
871 {
872     if (extManager.doHardWareEncodeFunc_ == nullptr && !extManager.LoadImageFwkExtNativeSo()) {
873         return false;
874     }
875     if (param.dstBuffer == nullptr || param.dstStride == 0) {
876         return false;
877     }
878     std::vector<std::vector<uint8_t>> inputs(1);
879     parser_->GetItemData(image->GetItemId(), &inputs[0], heif_header_data);
880     ProcessChunkHead(inputs[0].data(), inputs[0].size());
881 
882     int32_t retCode = extManager.hevcSoftwareDecodeFunc_(inputs, param);
883     if (retCode != 0) {
884         IMAGE_LOGE("SwDecodeSingleImage decode failed: %{public}d", retCode);
885         return false;
886     }
887     return true;
888 }
889 
IsEmptyBuffer(uint8_t * buffer,uint32_t width,uint32_t height,uint32_t bpp,uint32_t rowStride)890 static bool IsEmptyBuffer(uint8_t *buffer, uint32_t width, uint32_t height, uint32_t bpp, uint32_t rowStride)
891 {
892     if (buffer == nullptr) {
893         return true;
894     }
895     uint8_t *bufferRowStart = buffer;
896     uint32_t rowBytes = width * bpp;
897     for (uint32_t row = 0; row < height; ++row) {
898         for (uint32_t col = 0; col < rowBytes; ++col) {
899             if (bufferRowStart[col] != 0) {
900                 return false;
901             }
902         }
903         bufferRowStart += rowStride;
904     }
905     return true;
906 }
907 
FillAlphaChannel(std::shared_ptr<HeifImage> & masterImage,uint8_t * alphaMemory,size_t alphaStride,uint8_t * dstMemory,size_t dstRowStride)908 static bool FillAlphaChannel(std::shared_ptr<HeifImage> &masterImage, uint8_t *alphaMemory,
909                              size_t alphaStride, uint8_t *dstMemory, size_t dstRowStride)
910 {
911     // merge alpha channel
912     uint8_t *alphaRowStart = alphaMemory;
913     uint8_t *dstRowStart = dstMemory;
914     uint32_t width = masterImage->GetOriginalWidth();
915     uint32_t height = masterImage->GetOriginalHeight();
916     if (IsEmptyBuffer(reinterpret_cast<uint8_t*>(alphaMemory), width, height, 1, alphaStride)) {
917         return false;
918     }
919 
920     for (uint32_t row = 0; row < height; ++row) {
921         uint8_t *dstPixel = dstRowStart;
922         for (uint32_t col = 0; col < width; ++col) {
923             uint32_t alphaVal = static_cast<uint32_t>(alphaRowStart[col]);
924             dstPixel[PIXEL_OFFSET_0] = static_cast<uint8_t>(alphaVal * dstPixel[PIXEL_OFFSET_0] / MAX_ALPHA);
925             dstPixel[PIXEL_OFFSET_1] = static_cast<uint8_t>(alphaVal * dstPixel[PIXEL_OFFSET_1] / MAX_ALPHA);
926             dstPixel[PIXEL_OFFSET_2] = static_cast<uint8_t>(alphaVal * dstPixel[PIXEL_OFFSET_2] / MAX_ALPHA);
927             dstPixel[PIXEL_OFFSET_3] = static_cast<uint8_t>(alphaVal);
928             dstPixel += PIXEL_SIZE_4;
929         }
930         alphaRowStart += alphaStride;
931         dstRowStart += dstRowStride;
932     }
933     return true;
934 }
935 
IsValidAlphaImage(std::shared_ptr<HeifImage> & masterImage,std::shared_ptr<HeifImage> & alphaImage,PixelFormat dstPixFmt,bool isHardware)936 static bool IsValidAlphaImage(std::shared_ptr<HeifImage> &masterImage, std::shared_ptr<HeifImage> &alphaImage,
937                               PixelFormat dstPixFmt, bool isHardware)
938 {
939     return alphaImage != nullptr && alphaImage != masterImage &&
940         alphaImage->GetOriginalWidth() == masterImage->GetOriginalWidth() &&
941         alphaImage->GetOriginalHeight() == masterImage->GetOriginalHeight() &&
942         ((isHardware && alphaImage->GetDefaultPixelFormat() == HeifPixelFormat::YUV420) ||
943         (!isHardware && (alphaImage->GetDefaultPixelFormat() == HeifPixelFormat::YUV420 ||
944         alphaImage->GetDefaultPixelFormat() == HeifPixelFormat::MONOCHROME))) &&
945         alphaImage->GetLumaBitNum() == LUMA_8_BIT &&
946         (dstPixFmt == PixelFormat::RGBA_8888 || dstPixFmt == PixelFormat::BGRA_8888);
947 }
948 
HwApplyAlphaImage(std::shared_ptr<HeifImage> & masterImage,uint8_t * dstMemory,size_t dstRowStride)949 bool HeifDecoderImpl::HwApplyAlphaImage(std::shared_ptr<HeifImage> &masterImage,
950                                         uint8_t *dstMemory, size_t dstRowStride)
951 {
952     // check alpha image is available
953     if (masterImage == nullptr || IsDirectYUVDecode()) {
954         return false;
955     }
956     std::shared_ptr<HeifImage> alphaImage = masterImage->GetAlphaImage();
957     if (!IsValidAlphaImage(masterImage, alphaImage, outPixelFormat_, true)) {
958         return false;
959     }
960 
961     // decode alpha image
962     GridInfo alphaGridInfo;
963     sptr<SurfaceBuffer> hwBuffer;
964     InitGridInfo(alphaImage, alphaGridInfo);
965     bool decodeRes = HwDecodeImage(nullptr, alphaImage, alphaGridInfo, &hwBuffer, false);
966     if (!decodeRes) {
967         IMAGE_LOGE("hw decode alpha image failed");
968         return false;
969     }
970 
971     // merge alpha channel
972     return FillAlphaChannel(masterImage, reinterpret_cast<uint8_t *>(hwBuffer->GetVirAddr()),
973                             hwBuffer->GetStride(), dstMemory, dstRowStride);
974 }
975 
SwApplyAlphaImage(std::shared_ptr<HeifImage> & masterImage,uint8_t * dstMemory,size_t dstRowStride)976 bool HeifDecoderImpl::SwApplyAlphaImage(std::shared_ptr<HeifImage> &masterImage,
977                                         uint8_t *dstMemory, size_t dstRowStride)
978 {
979     // check alpha image is available
980     if (masterImage == nullptr || IsDirectYUVDecode()) {
981         return false;
982     }
983     std::shared_ptr<HeifImage> alphaImage = masterImage->GetAlphaImage();
984     if (!IsValidAlphaImage(masterImage, alphaImage, outPixelFormat_, false)) {
985         return false;
986     }
987 
988     GridInfo alphaGridInfo;
989     InitGridInfo(alphaImage, alphaGridInfo);
990     uint32_t alphaStride = alphaImage->GetOriginalWidth();
991     uint32_t alphaMemorySize = alphaStride * alphaImage->GetOriginalHeight();
992     PixelFormat alphaDstFmt = PixelFormat::ALPHA_8;
993     std::unique_ptr<uint8_t[]> alphaMemory = std::make_unique<uint8_t[]>(alphaMemorySize);
994     HevcSoftDecodeParam param {
995         alphaGridInfo, alphaDstFmt, alphaMemory.get(), alphaMemorySize, alphaStride, nullptr
996     };
997     bool decodeRes = SwDecodeImage(alphaImage, param, alphaGridInfo, false);
998     if (!decodeRes) {
999         IMAGE_LOGE("sw decode alpha image failed");
1000         return false;
1001     }
1002 
1003     // merge alpha channel
1004     return FillAlphaChannel(masterImage, alphaMemory.get(), alphaStride, dstMemory, dstRowStride);
1005 }
1006 
1007 // LCOV_EXCL_START
ConvertHwBufferPixelFormat(sptr<SurfaceBuffer> & hwBuffer,GridInfo & gridInfo,uint8_t * dstMemory,size_t dstRowStride)1008 bool HeifDecoderImpl::ConvertHwBufferPixelFormat(sptr<SurfaceBuffer> &hwBuffer, GridInfo &gridInfo,
1009                                                  uint8_t *dstMemory, size_t dstRowStride)
1010 {
1011     OH_NativeBuffer_Planes *srcBufferPlanesInfo = nullptr;
1012     hwBuffer->GetPlanesInfo((void **)&srcBufferPlanesInfo);
1013     if (srcBufferPlanesInfo == nullptr) {
1014         IMAGE_LOGE("find to get src buffer planes info");
1015         return false;
1016     }
1017 
1018     OH_NativeBuffer_Planes *dstBufferPlanesInfo = nullptr;
1019     if (dstHwBuffer_ != nullptr && dstHwBuffer_->GetFormat() != GRAPHIC_PIXEL_FMT_RGBA_1010102) {
1020         dstHwBuffer_->GetPlanesInfo((void **)&dstBufferPlanesInfo);
1021         if (dstBufferPlanesInfo == nullptr) {
1022             IMAGE_LOGE("fail to get dst buffer planes info");
1023             return false;
1024         }
1025     }
1026 
1027     PixelFormatConvertParam srcParam = {static_cast<uint8_t *>(hwBuffer->GetVirAddr()),
1028                                         gridInfo.displayWidth, gridInfo.displayHeight,
1029                                         static_cast<uint32_t>(hwBuffer->GetStride()),
1030                                         gridInfo.colorRangeFlag,
1031                                         srcBufferPlanesInfo,
1032                                         GraphicPixFmt2AvPixFmtForYuv(
1033                                             static_cast<GraphicPixelFormat>(hwBuffer->GetFormat()))};
1034     PixelFormatConvertParam dstParam = {dstMemory, gridInfo.displayWidth, gridInfo.displayHeight,
1035                                         static_cast<uint32_t>(dstRowStride),
1036                                         gridInfo.colorRangeFlag,
1037                                         dstBufferPlanesInfo,
1038                                         PixFmt2AvPixFmtForOutput(outPixelFormat_)};
1039     return ConvertPixelFormat(srcParam, dstParam);
1040 }
1041 // LCOV_EXCL_STOP
1042 
ProcessChunkHead(uint8_t * data,size_t len)1043 bool HeifDecoderImpl::ProcessChunkHead(uint8_t *data, size_t len)
1044 {
1045     if (len < CHUNK_HEAD_SIZE) {
1046         return false;
1047     }
1048     size_t index = 0;
1049     while (index < len - CHUNK_HEAD_SIZE) {
1050         size_t chunkLen = (data[index] << CHUNK_HEAD_SHIFT_24)
1051                 | (data[index + CHUNK_HEAD_OFFSET_1] << CHUNK_HEAD_SHIFT_16)
1052                 | (data[index + CHUNK_HEAD_OFFSET_2] << CHUNK_HEAD_SHIFT_8)
1053                 | (data[index + CHUNK_HEAD_OFFSET_3]);
1054         data[index] = 0;
1055         data[index + CHUNK_HEAD_OFFSET_1] = 0;
1056         data[index + CHUNK_HEAD_OFFSET_2] = 0;
1057         data[index + CHUNK_HEAD_OFFSET_3] = 1;
1058         index += (chunkLen + CHUNK_HEAD_SIZE);
1059     }
1060     return true;
1061 }
1062 
IsDirectYUVDecode()1063 bool HeifDecoderImpl::IsDirectYUVDecode()
1064 {
1065     if (dstHwBuffer_ == nullptr) {
1066         return false;
1067     }
1068     if (primaryImage_->GetLumaBitNum() == LUMA_10_BIT) {
1069         return outPixelFormat_ == Media::PixelFormat::YCRCB_P010 || outPixelFormat_ == Media::PixelFormat::YCBCR_P010;
1070     }
1071     return outPixelFormat_ == Media::PixelFormat::NV21 || outPixelFormat_ == Media::PixelFormat::NV12;
1072 }
1073 
decodeSequence(int frameIndex,HeifFrameInfo * frameInfo)1074 bool HeifDecoderImpl::decodeSequence(int frameIndex, HeifFrameInfo *frameInfo)
1075 {
1076     // unimplemented
1077     return false;
1078 }
1079 
1080 // LCOV_EXCL_START
setDstBuffer(uint8_t * dstBuffer,size_t rowStride,void * context)1081 void HeifDecoderImpl::setDstBuffer(uint8_t *dstBuffer, size_t rowStride, void *context)
1082 {
1083     if (dstMemory_ == nullptr) {
1084         dstMemory_ = dstBuffer;
1085         dstRowStride_ = rowStride;
1086     }
1087     dstHwBuffer_ = reinterpret_cast<SurfaceBuffer*>(context);
1088 }
1089 // LCOV_EXCL_STOP
1090 
setGainmapDstBuffer(uint8_t * dstBuffer,size_t rowStride)1091 void HeifDecoderImpl::setGainmapDstBuffer(uint8_t* dstBuffer, size_t rowStride)
1092 {
1093     if (gainmapDstMemory_ == nullptr) {
1094         gainmapDstMemory_ = dstBuffer;
1095         gainmapDstRowStride_ = rowStride;
1096     }
1097 }
1098 
setAuxiliaryDstBuffer(uint8_t * dstBuffer,size_t dstSize,size_t rowStride)1099 void HeifDecoderImpl::setAuxiliaryDstBuffer(uint8_t* dstBuffer, size_t dstSize, size_t rowStride)
1100 {
1101     auxiliaryDstMemory_ = dstBuffer;
1102     auxiliaryDstMemorySize_ = dstSize;
1103     auxiliaryDstRowStride_ = rowStride;
1104 }
1105 
getScanline(uint8_t * dst)1106 bool HeifDecoderImpl::getScanline(uint8_t *dst)
1107 {
1108     // no need to implement
1109     return true;
1110 }
1111 
skipScanlines(int count)1112 size_t HeifDecoderImpl::skipScanlines(int count)
1113 {
1114     // no need to implement
1115     return true;
1116 }
1117 
getImageInfo(HeifFrameInfo * frameInfo)1118 bool HeifDecoderImpl::getImageInfo(HeifFrameInfo *frameInfo)
1119 {
1120     if (frameInfo != nullptr) {
1121         *frameInfo = imageInfo_;
1122     }
1123     return true;
1124 }
1125 
getGainmapInfo(HeifFrameInfo * frameInfo)1126 bool HeifDecoderImpl::getGainmapInfo(HeifFrameInfo* frameInfo)
1127 {
1128     if (frameInfo != nullptr) {
1129         *frameInfo = gainmapImageInfo_;
1130     }
1131     return true;
1132 }
1133 
getAuxiliaryMapInfo(HeifFrameInfo * frameInfo)1134 bool HeifDecoderImpl::getAuxiliaryMapInfo(HeifFrameInfo* frameInfo)
1135 {
1136     if (frameInfo != nullptr) {
1137         *frameInfo = auxiliaryImageInfo_;
1138     }
1139     return true;
1140 }
1141 
getTmapInfo(HeifFrameInfo * frameInfo)1142 bool HeifDecoderImpl::getTmapInfo(HeifFrameInfo* frameInfo)
1143 {
1144     if (frameInfo != nullptr) {
1145         *frameInfo = tmapInfo_;
1146     }
1147     return true;
1148 }
1149 
getHdrType()1150 HeifImageHdrType HeifDecoderImpl::getHdrType()
1151 {
1152     std::vector<uint8_t> uwaInfo = primaryImage_->GetUWAInfo();
1153     if (primaryImage_->GetLumaBitNum() == LUMA_10_BIT && imageInfo_.hasNclxColor &&
1154         imageInfo_.nclxColor.colorPrimaries == BT2020_PRIMARIES) {
1155         return uwaInfo.empty() ? HeifImageHdrType::ISO_SINGLE : HeifImageHdrType::VIVID_SINGLE;
1156     }
1157     if (gainmapImage_ != nullptr) {
1158         return uwaInfo.empty() ? HeifImageHdrType::ISO_DUAL : HeifImageHdrType::VIVID_DUAL;
1159     }
1160     return HeifImageHdrType::UNKNOWN;
1161 }
1162 
getVividMetadata(std::vector<uint8_t> & uwaInfo,std::vector<uint8_t> & displayInfo,std::vector<uint8_t> & lightInfo)1163 void HeifDecoderImpl::getVividMetadata(std::vector<uint8_t>& uwaInfo, std::vector<uint8_t>& displayInfo,
1164     std::vector<uint8_t>& lightInfo)
1165 {
1166     uwaInfo = primaryImage_->GetUWAInfo();
1167     displayInfo = primaryImage_->GetDisplayInfo();
1168     lightInfo = primaryImage_->GetLightInfo();
1169 }
1170 
getISOMetadata(std::vector<uint8_t> & isoMetadata)1171 void HeifDecoderImpl::getISOMetadata(std::vector<uint8_t>& isoMetadata)
1172 {
1173     isoMetadata = primaryImage_->GetISOMetadata();
1174 }
1175 
getFragmentMetadata(Media::Rect & fragmentMetadata)1176 void HeifDecoderImpl::getFragmentMetadata(Media::Rect& fragmentMetadata)
1177 {
1178     HeifFragmentMetadata metadata = primaryImage_->GetFragmentMetadata();
1179     fragmentMetadata.width = static_cast<int32_t>(metadata.width);
1180     fragmentMetadata.height = static_cast<int32_t>(metadata.height);
1181     fragmentMetadata.left = static_cast<int32_t>(metadata.horizontalOffset);
1182     fragmentMetadata.top = static_cast<int32_t>(metadata.verticalOffset);
1183 }
1184 
getErrMsg(std::string & errMsg)1185 void HeifDecoderImpl::getErrMsg(std::string& errMsg)
1186 {
1187     errMsg = errMsg_;
1188 }
1189 
SetHardwareDecodeErrMsg(const uint32_t width,const uint32_t height)1190 void HeifDecoderImpl::SetHardwareDecodeErrMsg(const uint32_t width, const uint32_t height)
1191 {
1192     std::stringstream sstream;
1193     sstream << "HEIF Hardware Decode Failed, Width: ";
1194     sstream << width;
1195     sstream << ", Height: ";
1196     sstream << height;
1197     errMsg_ = sstream.str();
1198 }
1199 } // namespace ImagePlugin
1200 } // namespace OHOS
1201 #endif
1202 
CreateHeifDecoderImpl(void)1203 HeifDecoder* CreateHeifDecoderImpl(void)
1204 {
1205 #ifdef HEIF_HW_DECODE_ENABLE
1206     return new OHOS::ImagePlugin::HeifDecoderImpl();
1207 #else
1208     return nullptr;
1209 #endif
1210 }
1211