1 /* 2 * Copyright (C) 2021 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 #ifndef INTERFACES_INNERKITS_INCLUDE_PIXEL_MAP_H_ 17 #define INTERFACES_INNERKITS_INCLUDE_PIXEL_MAP_H_ 18 19 #include <atomic> 20 #include <cstdint> 21 #include <memory> 22 #include <mutex> 23 #include <shared_mutex> 24 #ifdef IMAGE_COLORSPACE_FLAG 25 #include "color_space.h" 26 #endif 27 #include "image_type.h" 28 #include "parcel.h" 29 #ifdef IMAGE_PURGEABLE_PIXELMAP 30 #include "purgeable_mem_base.h" 31 #include "purgeable_mem_builder.h" 32 #endif 33 34 namespace OHOS::Rosen { 35 class RSMarshallingHelper; 36 }; 37 38 namespace OHOS { 39 namespace Media { 40 struct HdrMetadata; 41 enum class ImageHdrType : int32_t; 42 using TransColorProc = bool (*)(const uint8_t *in, uint32_t inCount, uint32_t *out, uint32_t outCount); 43 using CustomFreePixelMap = void (*)(void *addr, void *context, uint32_t size); 44 45 typedef struct { 46 float scaleX; 47 float scaleY; 48 float rotateD; 49 float cropLeft; 50 float cropTop; 51 float cropWidth; 52 float cropHeight; 53 float translateX; 54 float translateY; 55 bool flipX; 56 bool flipY; 57 } TransformData; 58 59 struct InitializationOptions { 60 Size size; 61 PixelFormat srcPixelFormat = PixelFormat::BGRA_8888; 62 PixelFormat pixelFormat = PixelFormat::UNKNOWN; 63 AlphaType alphaType = AlphaType::IMAGE_ALPHA_TYPE_UNKNOWN; 64 ScaleMode scaleMode = ScaleMode::FIT_TARGET_SIZE; 65 int32_t srcRowStride = 0; 66 bool editable = false; 67 bool useSourceIfMatch = false; 68 bool useDMA = false; 69 }; 70 struct TransInfos; 71 72 // Build ARGB_8888 pixel value 73 constexpr uint8_t ARGB_MASK = 0xFF; 74 constexpr uint8_t ARGB_A_SHIFT = 24; 75 constexpr uint8_t ARGB_R_SHIFT = 16; 76 constexpr uint8_t ARGB_G_SHIFT = 8; 77 constexpr uint8_t ARGB_B_SHIFT = 0; 78 // Define pixel map malloc max size 600MB 79 // Memory copy will be performed twice on heap memory during IPC, so the size has to be limited 80 constexpr int32_t PIXEL_MAP_MAX_RAM_SIZE = 600 * 1024 * 1024; 81 82 typedef struct PixelMapError { 83 uint32_t errorCode = 0; 84 std::string errorInfo = ""; 85 } PIXEL_MAP_ERR; 86 87 typedef struct BuildParam { 88 int32_t offset_ = 0; 89 int32_t width_ = 0; 90 bool flag_ = true; 91 } BUILD_PARAM; 92 93 struct PixelMemInfo { 94 uint8_t* base = nullptr; 95 void* context = nullptr; 96 int32_t bufferSize = 0; 97 AllocatorType allocatorType = AllocatorType::SHARE_MEM_ALLOC; 98 bool isAstc = false; 99 }; 100 101 class ExifMetadata; 102 103 class PixelMap : public Parcelable, public PIXEL_MAP_ERR { 104 public: 105 static std::atomic<uint32_t> currentId; PixelMap()106 PixelMap() 107 { 108 uniqueId_ = currentId.fetch_add(1, std::memory_order_relaxed); 109 } 110 virtual ~PixelMap(); 111 NATIVEEXPORT static std::unique_ptr<PixelMap> Create(const uint32_t *colors, uint32_t colorLength, 112 const InitializationOptions &opts); 113 NATIVEEXPORT static std::unique_ptr<PixelMap> Create(const uint32_t *colors, uint32_t colorLength, int32_t offset, 114 int32_t stride, const InitializationOptions &opts); 115 NATIVEEXPORT static std::unique_ptr<PixelMap> Create(const uint32_t *colors, uint32_t colorLength, int32_t offset, 116 int32_t stride, const InitializationOptions &opts, bool useCustomFormat); 117 NATIVEEXPORT static std::unique_ptr<PixelMap> Create(const uint32_t *colors, uint32_t colorLength, 118 BUILD_PARAM &info, const InitializationOptions &opts, int &errorCode); 119 NATIVEEXPORT static std::unique_ptr<PixelMap> Create(const InitializationOptions &opts); 120 NATIVEEXPORT static std::unique_ptr<PixelMap> Create(PixelMap &source, const InitializationOptions &opts); 121 NATIVEEXPORT static std::unique_ptr<PixelMap> Create(PixelMap &source, const Rect &srcRect, 122 const InitializationOptions &opts); 123 NATIVEEXPORT static std::unique_ptr<PixelMap> Create(PixelMap &source, const Rect &srcRect, 124 const InitializationOptions &opts, int32_t &errorCode); 125 126 NATIVEEXPORT virtual uint32_t SetImageInfo(ImageInfo &info); 127 NATIVEEXPORT virtual uint32_t SetImageInfo(ImageInfo &info, bool isReused); 128 NATIVEEXPORT virtual const uint8_t *GetPixel(int32_t x, int32_t y); 129 NATIVEEXPORT virtual const uint8_t *GetPixel8(int32_t x, int32_t y); 130 NATIVEEXPORT virtual const uint16_t *GetPixel16(int32_t x, int32_t y); 131 NATIVEEXPORT virtual const uint32_t *GetPixel32(int32_t x, int32_t y); 132 NATIVEEXPORT virtual bool GetARGB32Color(int32_t x, int32_t y, uint32_t &color); 133 NATIVEEXPORT virtual void SetPixelsAddr(void *addr, void *context, uint32_t size, AllocatorType type, 134 CustomFreePixelMap func); 135 NATIVEEXPORT virtual int32_t GetPixelBytes(); 136 NATIVEEXPORT virtual int32_t GetRowBytes(); 137 NATIVEEXPORT virtual int32_t GetByteCount(); 138 NATIVEEXPORT virtual int32_t GetWidth(); 139 NATIVEEXPORT virtual int32_t GetHeight(); GetAstcRealSize(Size & size)140 NATIVEEXPORT void GetAstcRealSize(Size &size) 141 { 142 size = astcrealSize_; 143 } SetAstcRealSize(Size size)144 NATIVEEXPORT void SetAstcRealSize(Size size) 145 { 146 astcrealSize_ = size; 147 } 148 NATIVEEXPORT void GetTransformData(TransformData &transformData); 149 NATIVEEXPORT void SetTransformData(TransformData transformData); 150 NATIVEEXPORT virtual int32_t GetBaseDensity(); 151 NATIVEEXPORT virtual void scale(float xAxis, float yAxis); 152 NATIVEEXPORT virtual void scale(float xAxis, float yAxis, const AntiAliasingOption &option); 153 NATIVEEXPORT virtual bool resize(float xAxis, float yAxis); 154 NATIVEEXPORT virtual void translate(float xAxis, float yAxis); 155 NATIVEEXPORT virtual void rotate(float degrees); 156 NATIVEEXPORT virtual void flip(bool xAxis, bool yAxis); 157 NATIVEEXPORT virtual uint32_t crop(const Rect &rect); 158 NATIVEEXPORT virtual void GetImageInfo(ImageInfo &imageInfo); 159 NATIVEEXPORT virtual PixelFormat GetPixelFormat(); 160 NATIVEEXPORT virtual ColorSpace GetColorSpace(); 161 NATIVEEXPORT virtual AlphaType GetAlphaType(); 162 NATIVEEXPORT virtual uint32_t SetAlpha(const float percent); 163 NATIVEEXPORT virtual const uint8_t *GetPixels(); 164 NATIVEEXPORT virtual uint8_t GetARGB32ColorA(uint32_t color); 165 NATIVEEXPORT virtual uint8_t GetARGB32ColorR(uint32_t color); 166 NATIVEEXPORT virtual uint8_t GetARGB32ColorG(uint32_t color); 167 NATIVEEXPORT virtual uint8_t GetARGB32ColorB(uint32_t color); 168 // Config the pixel map parameter 169 NATIVEEXPORT virtual bool IsSameImage(const PixelMap &other); 170 NATIVEEXPORT virtual uint32_t ReadPixels(const uint64_t &bufferSize, const uint32_t &offset, const uint32_t &stride, 171 const Rect ®ion, uint8_t *dst); 172 NATIVEEXPORT virtual uint32_t ReadPixels(const uint64_t &bufferSize, uint8_t *dst); 173 NATIVEEXPORT virtual uint32_t ReadARGBPixels(const uint64_t &bufferSize, uint8_t *dst); 174 NATIVEEXPORT virtual uint32_t ReadPixel(const Position &pos, uint32_t &dst); 175 NATIVEEXPORT virtual uint32_t ResetConfig(const Size &size, const PixelFormat &format); 176 NATIVEEXPORT virtual bool SetAlphaType(const AlphaType &alphaType); 177 NATIVEEXPORT virtual uint32_t WritePixel(const Position &pos, const uint32_t &color); 178 NATIVEEXPORT virtual uint32_t WritePixels(const uint8_t *source, const uint64_t &bufferSize, const uint32_t &offset, 179 const uint32_t &stride, const Rect ®ion); 180 NATIVEEXPORT virtual uint32_t WritePixels(const uint8_t *source, const uint64_t &bufferSize); 181 NATIVEEXPORT virtual bool WritePixels(const uint32_t &color); 182 NATIVEEXPORT virtual void FreePixelMap(); 183 NATIVEEXPORT bool IsStrideAlignment(); 184 NATIVEEXPORT virtual AllocatorType GetAllocatorType(); 185 NATIVEEXPORT virtual void *GetFd() const; 186 NATIVEEXPORT virtual void SetFreePixelMapProc(CustomFreePixelMap func); 187 NATIVEEXPORT virtual void SetTransformered(bool isTransformered); 188 NATIVEEXPORT uint32_t ConvertAlphaFormat(PixelMap &wPixelMap, const bool isPremul); SetPixelMapError(uint32_t code,std::string info)189 NATIVEEXPORT void SetPixelMapError(uint32_t code, std::string info) 190 { 191 errorCode = code; 192 errorInfo = info; 193 } 194 ConstructPixelMapError(PIXEL_MAP_ERR & err,uint32_t code,std::string info)195 NATIVEEXPORT static void ConstructPixelMapError(PIXEL_MAP_ERR &err, uint32_t code, std::string info) 196 { 197 err.errorCode = code; 198 err.errorInfo = info; 199 } 200 201 NATIVEEXPORT virtual void SetRowStride(uint32_t stride); GetRowStride()202 NATIVEEXPORT virtual int32_t GetRowStride() 203 { 204 return rowStride_; 205 } GetCapacity()206 NATIVEEXPORT virtual uint32_t GetCapacity() 207 { 208 return pixelsSize_; 209 } 210 IsEditable()211 NATIVEEXPORT virtual bool IsEditable() 212 { 213 return editable_; 214 } 215 IsTransformered()216 NATIVEEXPORT virtual bool IsTransformered() 217 { 218 return isTransformered_; 219 } 220 221 // judgement whether create pixelmap use source as result IsSourceAsResponse()222 NATIVEEXPORT virtual bool IsSourceAsResponse() 223 { 224 return useSourceAsResponse_; 225 } 226 GetWritablePixels()227 NATIVEEXPORT virtual void *GetWritablePixels() const 228 { 229 return static_cast<void *>(data_); 230 } 231 GetUniqueId()232 NATIVEEXPORT virtual uint32_t GetUniqueId() const 233 { 234 return uniqueId_; 235 } 236 237 NATIVEEXPORT virtual bool Marshalling(Parcel &data) const override; 238 NATIVEEXPORT static PixelMap *Unmarshalling(Parcel &data); 239 NATIVEEXPORT static PixelMap *Unmarshalling(Parcel &parcel, PIXEL_MAP_ERR &error); 240 NATIVEEXPORT virtual bool EncodeTlv(std::vector<uint8_t> &buff) const; 241 NATIVEEXPORT static PixelMap *DecodeTlv(std::vector<uint8_t> &buff); SetImageYUVInfo(YUVDataInfo & yuvinfo)242 NATIVEEXPORT virtual void SetImageYUVInfo(YUVDataInfo &yuvinfo) 243 { 244 yuvDataInfo_ = yuvinfo; 245 } 246 NATIVEEXPORT virtual void AssignYuvDataOnType(PixelFormat format, int32_t width, int32_t height); 247 NATIVEEXPORT virtual void UpdateYUVDataInfo(PixelFormat format, int32_t width, int32_t height, 248 YUVStrideInfo &strides); GetImageYUVInfo(YUVDataInfo & yuvInfo)249 NATIVEEXPORT virtual void GetImageYUVInfo(YUVDataInfo &yuvInfo) const 250 { 251 yuvInfo = yuvDataInfo_; 252 } 253 #ifdef IMAGE_COLORSPACE_FLAG 254 // -------[inner api for ImageSource/ImagePacker codec] it will get a colorspace object pointer----begin---- 255 NATIVEEXPORT void InnerSetColorSpace(const OHOS::ColorManager::ColorSpace &grColorSpace, bool direct = false); 256 NATIVEEXPORT OHOS::ColorManager::ColorSpace InnerGetGrColorSpace(); InnerGetGrColorSpacePtr()257 NATIVEEXPORT std::shared_ptr<OHOS::ColorManager::ColorSpace> InnerGetGrColorSpacePtr() 258 { 259 return grColorSpace_; 260 } 261 NATIVEEXPORT virtual uint32_t ApplyColorSpace(const OHOS::ColorManager::ColorSpace &grColorSpace); 262 // -------[inner api for ImageSource/ImagePacker codec] it will get a colorspace object pointer----end------- 263 #endif 264 265 #ifdef IMAGE_PURGEABLE_PIXELMAP IsPurgeable()266 NATIVEEXPORT bool IsPurgeable() const 267 { 268 return purgeableMemPtr_ != nullptr; 269 } 270 GetPurgeableMemPtr()271 NATIVEEXPORT std::shared_ptr<PurgeableMem::PurgeableMemBase> GetPurgeableMemPtr() const 272 { 273 return purgeableMemPtr_; 274 } 275 SetPurgeableMemPtr(std::shared_ptr<PurgeableMem::PurgeableMemBase> pmPtr)276 NATIVEEXPORT void SetPurgeableMemPtr(std::shared_ptr<PurgeableMem::PurgeableMemBase> pmPtr) 277 { 278 purgeableMemPtr_ = pmPtr; 279 } 280 #endif 281 IsAstc()282 NATIVEEXPORT bool IsAstc() 283 { 284 return isAstc_; 285 } 286 SetAstc(bool isAstc)287 NATIVEEXPORT void SetAstc(bool isAstc) 288 { 289 isAstc_ = isAstc; 290 } 291 GetExifMetadata()292 NATIVEEXPORT std::shared_ptr<ExifMetadata> GetExifMetadata() 293 { 294 return exifMetadata_; 295 } 296 SetExifMetadata(std::shared_ptr<ExifMetadata> & ptr)297 NATIVEEXPORT void SetExifMetadata(std::shared_ptr<ExifMetadata> &ptr) 298 { 299 exifMetadata_ = ptr; 300 } 301 GetHdrMetadata()302 NATIVEEXPORT std::shared_ptr<HdrMetadata> GetHdrMetadata() 303 { 304 return hdrMetadata_; 305 } 306 SetHdrMetadata(const std::shared_ptr<HdrMetadata> & metadata)307 NATIVEEXPORT void SetHdrMetadata(const std::shared_ptr<HdrMetadata> &metadata) 308 { 309 hdrMetadata_ = metadata; 310 } 311 GetHdrType()312 NATIVEEXPORT ImageHdrType GetHdrType() 313 { 314 return hdrType_; 315 } 316 SetHdrType(ImageHdrType hdrType)317 NATIVEEXPORT void SetHdrType(ImageHdrType hdrType) 318 { 319 hdrType_ = hdrType; 320 } 321 322 NATIVEEXPORT uint32_t GetImagePropertyInt(const std::string &key, int32_t &value); 323 NATIVEEXPORT uint32_t GetImagePropertyString(const std::string &key, std::string &value); 324 NATIVEEXPORT uint32_t ModifyImageProperty(const std::string &key, const std::string &value); 325 NATIVEEXPORT uint32_t SetMemoryName(std::string pixelMapName); 326 327 NATIVEEXPORT bool IsHdr(); 328 NATIVEEXPORT uint32_t ToSdr(); 329 // format support rgba8888, nv12, nv21. The default value is rgba8888 330 // If toSRGB is false, pixelmap will be converted to display_p3 331 NATIVEEXPORT uint32_t ToSdr(PixelFormat format, bool toSRGB); 332 // use for hdr pixelmap, If isSRGB is false, the colorspace is p3 when converting to SDR. 333 NATIVEEXPORT void SetToSdrColorSpaceIsSRGB(bool isSRGB); 334 NATIVEEXPORT bool GetToSdrColorSpaceIsSRGB(); 335 SetAllocatorType(AllocatorType allocatorType)336 NATIVEEXPORT void SetAllocatorType(AllocatorType allocatorType) 337 { 338 allocatorType_ = allocatorType; 339 } 340 341 // unmap方案, 减少RenderService内存占用 342 NATIVEEXPORT bool UnMap(); 343 NATIVEEXPORT bool ReMap(); IsUnMap()344 NATIVEEXPORT bool IsUnMap() 345 { 346 std::lock_guard<std::mutex> lock(*unmapMutex_); 347 return isUnMap_; 348 } IncreaseUseCount()349 NATIVEEXPORT void IncreaseUseCount() 350 { 351 std::lock_guard<std::mutex> lock(*unmapMutex_); 352 useCount_ += 1; 353 } DecreaseUseCount()354 NATIVEEXPORT void DecreaseUseCount() 355 { 356 std::lock_guard<std::mutex> lock(*unmapMutex_); 357 if (useCount_ > 0) { 358 useCount_ -= 1; 359 } 360 } ResetUseCount()361 NATIVEEXPORT void ResetUseCount() 362 { 363 std::lock_guard<std::mutex> lock(*unmapMutex_); 364 useCount_ = 0; 365 } GetUseCount()366 NATIVEEXPORT uint64_t GetUseCount() 367 { 368 std::lock_guard<std::mutex> lock(*unmapMutex_); 369 return useCount_; 370 } GetUnMapCount()371 NATIVEEXPORT uint64_t GetUnMapCount() 372 { 373 std::lock_guard<std::mutex> lock(*unmapMutex_); 374 return unMapCount_; 375 } 376 377 // pixelmap with DMA memory should be marked dirty when memory was changed MarkDirty()378 NATIVEEXPORT void MarkDirty() 379 { 380 isMemoryDirty_ = true; 381 } 382 IsMemoryDirty()383 NATIVEEXPORT bool IsMemoryDirty() 384 { 385 return isMemoryDirty_; 386 } 387 388 static int32_t GetRGBxRowDataSize(const ImageInfo& info); 389 static int32_t GetRGBxByteCount(const ImageInfo& info); 390 static int32_t GetYUVByteCount(const ImageInfo& info); 391 static int32_t GetAllocatedByteCount(const ImageInfo& info); setAllocatorType(AllocatorType allocatorType)392 NATIVEEXPORT void setAllocatorType(AllocatorType allocatorType) 393 { 394 allocatorType_ = allocatorType; 395 } 396 397 protected: 398 static constexpr uint8_t TLV_VARINT_BITS = 7; 399 static constexpr uint8_t TLV_VARINT_MASK = 0x7F; 400 static constexpr uint8_t TLV_VARINT_MORE = 0x80; 401 static constexpr uint8_t TLV_END = 0x00; 402 static constexpr uint8_t TLV_IMAGE_WIDTH = 0x01; 403 static constexpr uint8_t TLV_IMAGE_HEIGHT = 0x02; 404 static constexpr uint8_t TLV_IMAGE_PIXELFORMAT = 0x03; 405 static constexpr uint8_t TLV_IMAGE_COLORSPACE = 0x04; 406 static constexpr uint8_t TLV_IMAGE_ALPHATYPE = 0x05; 407 static constexpr uint8_t TLV_IMAGE_BASEDENSITY = 0x06; 408 static constexpr uint8_t TLV_IMAGE_ALLOCATORTYPE = 0x07; 409 static constexpr uint8_t TLV_IMAGE_DATA = 0x08; 410 static constexpr size_t MAX_IMAGEDATA_SIZE = 128 * 1024 * 1024; // 128M 411 static constexpr size_t MIN_IMAGEDATA_SIZE = 32 * 1024; // 32k 412 friend class ImageSource; 413 friend class OHOS::Rosen::RSMarshallingHelper; 414 static bool ALPHA8ToARGB(const uint8_t *in, uint32_t inCount, uint32_t *out, uint32_t outCount); 415 static bool RGB565ToARGB(const uint8_t *in, uint32_t inCount, uint32_t *out, uint32_t outCount); 416 static bool ARGB8888ToARGB(const uint8_t *in, uint32_t inCount, uint32_t *out, uint32_t outCount); 417 static bool RGBA8888ToARGB(const uint8_t *in, uint32_t inCount, uint32_t *out, uint32_t outCount); 418 static bool BGRA8888ToARGB(const uint8_t *in, uint32_t inCount, uint32_t *out, uint32_t outCount); 419 static bool RGB888ToARGB(const uint8_t *in, uint32_t inCount, uint32_t *out, uint32_t outCount); 420 static bool CheckParams(const uint32_t *colors, uint32_t colorLength, int32_t offset, int32_t stride, 421 const InitializationOptions &opts); 422 static void UpdatePixelsAlpha(const AlphaType &alphaType, const PixelFormat &pixelFormat, uint8_t *dstPixels, 423 PixelMap &dstPixelMap); 424 static void InitDstImageInfo(const InitializationOptions &opts, const ImageInfo &srcImageInfo, 425 ImageInfo &dstImageInfo); 426 static bool CopyPixMapToDst(PixelMap &source, void* &dstPixels, int &fd, uint32_t bufferSize); 427 static bool CopyPixelMap(PixelMap &source, PixelMap &dstPixelMap, int32_t &error); 428 static bool CopyPixelMap(PixelMap &source, PixelMap &dstPixelMap); 429 static bool SourceCropAndConvert(PixelMap &source, const ImageInfo &srcImageInfo, const ImageInfo &dstImageInfo, 430 const Rect &srcRect, PixelMap &dstPixelMap); 431 static bool IsSameSize(const Size &src, const Size &dst); 432 static bool ScalePixelMap(const Size &targetSize, const Size &dstSize, const ScaleMode &scaleMode, 433 PixelMap &dstPixelMap); 434 static bool IsYuvFormat(PixelFormat format); 435 bool GetPixelFormatDetail(const PixelFormat format); 436 uint32_t CheckAlphaFormatInput(PixelMap &wPixelMap, const bool isPremul); 437 bool CheckPixelsInput(const uint8_t *dst, const uint64_t &bufferSize, const uint32_t &offset, 438 const uint32_t &stride, const Rect ®ion); 439 void ReleaseSharedMemory(void *addr, void *context, uint32_t size); 440 static void ReleaseBuffer(AllocatorType allocatorType, int fd, uint64_t dataSize, void **buffer); 441 static void *AllocSharedMemory(const uint64_t bufferSize, int &fd, uint32_t uniqueId); 442 bool WritePropertiesToParcel(Parcel &parcel) const; 443 bool ReadPropertiesFromParcel(Parcel &parcel, ImageInfo &imgInfo, AllocatorType &allocatorType, 444 int32_t &bufferSize, PIXEL_MAP_ERR &error); 445 bool WriteMemInfoToParcel(Parcel &parcel, const int32_t &bufferSize) const; 446 static bool ReadMemInfoFromParcel(Parcel &parcel, PixelMemInfo &pixelMemInfo, PIXEL_MAP_ERR &error); 447 bool WriteTransformDataToParcel(Parcel &parcel) const; 448 bool ReadTransformData(Parcel &parcel, PixelMap *pixelMap); 449 bool WriteAstcRealSizeToParcel(Parcel &parcel) const; 450 bool ReadAstcRealSize(Parcel &parcel, PixelMap *pixelMap); 451 bool WriteYuvDataInfoToParcel(Parcel &parcel) const; 452 bool ReadYuvDataInfoFromParcel(Parcel &parcel, PixelMap *pixelMap); 453 uint32_t SetRowDataSizeForImageInfo(ImageInfo info); SetEditable(bool editable)454 void SetEditable(bool editable) 455 { 456 editable_ = editable; 457 } 458 ResetPixelMap()459 void ResetPixelMap() 460 { 461 rowDataSize_ = 0; 462 pixelBytes_ = 0; 463 colorProc_ = nullptr; 464 } 465 CheckValidParam(int32_t x,int32_t y)466 bool CheckValidParam(int32_t x, int32_t y) 467 { 468 return isUnMap_ || (data_ == nullptr) || 469 (x >= imageInfo_.size.width) || (x < 0) || (y >= imageInfo_.size.height) || 470 (y < 0) || (pixelsSize_ < static_cast<uint64_t>(rowDataSize_) * imageInfo_.size.height) 471 ? false 472 : true; 473 } 474 475 static void ReleaseMemory(AllocatorType allocType, void *addr, void *context, uint32_t size); 476 static bool UpdatePixelMapMemInfo(PixelMap *pixelMap, ImageInfo &imgInfo, PixelMemInfo &pixelMemInfo); 477 bool WriteImageData(Parcel &parcel, size_t size) const; 478 bool WriteAshmemDataToParcel(Parcel &parcel, size_t size) const; 479 static uint8_t *ReadImageData(Parcel &parcel, int32_t size); 480 static uint8_t *ReadHeapDataFromParcel(Parcel &parcel, int32_t bufferSize); 481 static uint8_t *ReadAshmemDataFromParcel(Parcel &parcel, int32_t bufferSize); 482 static int ReadFileDescriptor(Parcel &parcel); 483 static bool WriteFileDescriptor(Parcel &parcel, int fd); 484 static bool ReadImageInfo(Parcel &parcel, ImageInfo &imgInfo); 485 bool WriteImageInfo(Parcel &parcel) const; 486 void WriteUint8(std::vector<uint8_t> &buff, uint8_t value) const; 487 static uint8_t ReadUint8(std::vector<uint8_t> &buff, int32_t &cursor); 488 uint8_t GetVarintLen(int32_t value) const; 489 void WriteVarint(std::vector<uint8_t> &buff, int32_t value) const; 490 static int32_t ReadVarint(std::vector<uint8_t> &buff, int32_t &cursor); 491 void WriteData(std::vector<uint8_t> &buff, const uint8_t *data, 492 const int32_t &height, const int32_t &rowDataSize, const int32_t &rowStride) const; 493 static uint8_t *ReadData(std::vector<uint8_t> &buff, int32_t size, int32_t &cursor); 494 static void ReadTlvAttr(std::vector<uint8_t> &buff, ImageInfo &info, int32_t &type, int32_t &size, uint8_t **data); 495 bool DoTranslation(TransInfos &infos, const AntiAliasingOption &option = AntiAliasingOption::NONE); 496 void UpdateImageInfo(); 497 bool IsYuvFormat() const; 498 static int32_t ConvertPixelAlpha(const void *srcPixels, const int32_t srcLength, const ImageInfo &srcInfo, 499 void *dstPixels, const ImageInfo &dstInfo); 500 // used to close fd after mmap in RenderService when memory type is shared-mem or dma. 501 bool CloseFd(); 502 503 uint8_t *data_ = nullptr; 504 // this info SHOULD be the final info for decoded pixelmap, not the original image info 505 ImageInfo imageInfo_; 506 int32_t rowDataSize_ = 0; 507 int32_t rowStride_ = 0; 508 int32_t pixelBytes_ = 0; 509 TransColorProc colorProc_ = nullptr; 510 void *context_ = nullptr; 511 CustomFreePixelMap custFreePixelMap_ = nullptr; 512 CustomFreePixelMap freePixelMapProc_ = nullptr; 513 AllocatorType allocatorType_ = AllocatorType::SHARE_MEM_ALLOC; 514 uint32_t pixelsSize_ = 0; 515 bool editable_ = false; 516 bool useSourceAsResponse_ = false; 517 bool isTransformered_ = false; 518 std::shared_ptr<std::mutex> transformMutex_ = std::make_shared<std::mutex>(); 519 520 // only used by rosen backend 521 uint32_t uniqueId_ = 0; 522 bool isAstc_ = false; 523 TransformData transformData_ = {1, 1, 0, 0, 0, 0, 0, 0, 0, false, false}; 524 Size astcrealSize_; 525 std::shared_ptr<HdrMetadata> hdrMetadata_ = nullptr; 526 ImageHdrType hdrType_; 527 528 #ifdef IMAGE_COLORSPACE_FLAG 529 std::shared_ptr<OHOS::ColorManager::ColorSpace> grColorSpace_ = nullptr; 530 #else 531 std::shared_ptr<uint8_t> grColorSpace_ = nullptr; 532 #endif 533 534 #ifdef IMAGE_PURGEABLE_PIXELMAP 535 std::shared_ptr<PurgeableMem::PurgeableMemBase> purgeableMemPtr_ = nullptr; 536 #else 537 std::shared_ptr<uint8_t> purgeableMemPtr_ = nullptr; 538 #endif 539 YUVDataInfo yuvDataInfo_; 540 std::shared_ptr<ExifMetadata> exifMetadata_ = nullptr; 541 std::shared_ptr<std::mutex> metadataMutex_ = std::make_shared<std::mutex>(); 542 std::shared_ptr<std::mutex> translationMutex_ = std::make_shared<std::mutex>(); 543 bool toSdrColorIsSRGB_ = false; 544 private: 545 // unmap方案, 减少RenderService内存占用 546 bool isUnMap_ = false; 547 uint64_t useCount_ = 0ULL; 548 uint64_t unMapCount_ = 0; 549 std::shared_ptr<std::mutex> unmapMutex_ = std::make_shared<std::mutex>(); 550 551 // used to mark whether DMA memory should be refreshed 552 mutable bool isMemoryDirty_; 553 }; 554 } // namespace Media 555 } // namespace OHOS 556 557 #endif // INTERFACES_INNERKITS_INCLUDE_PIXEL_MAP_H_ 558