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 SetModifiable(bool modifiable)216 NATIVEEXPORT virtual void SetModifiable(bool modifiable) 217 { 218 modifiable_ = modifiable; 219 } IsModifiable()220 NATIVEEXPORT virtual bool IsModifiable() 221 { 222 return modifiable_; 223 } 224 IsTransformered()225 NATIVEEXPORT virtual bool IsTransformered() 226 { 227 return isTransformered_; 228 } 229 230 // judgement whether create pixelmap use source as result IsSourceAsResponse()231 NATIVEEXPORT virtual bool IsSourceAsResponse() 232 { 233 return useSourceAsResponse_; 234 } 235 GetWritablePixels()236 NATIVEEXPORT virtual void *GetWritablePixels() const 237 { 238 return static_cast<void *>(data_); 239 } 240 GetUniqueId()241 NATIVEEXPORT virtual uint32_t GetUniqueId() const 242 { 243 return uniqueId_; 244 } 245 246 NATIVEEXPORT virtual bool Marshalling(Parcel &data) const override; 247 NATIVEEXPORT static PixelMap *Unmarshalling(Parcel &data); 248 NATIVEEXPORT static PixelMap *Unmarshalling(Parcel &parcel, PIXEL_MAP_ERR &error); 249 NATIVEEXPORT virtual bool EncodeTlv(std::vector<uint8_t> &buff) const; 250 NATIVEEXPORT static PixelMap *DecodeTlv(std::vector<uint8_t> &buff); SetImageYUVInfo(YUVDataInfo & yuvinfo)251 NATIVEEXPORT virtual void SetImageYUVInfo(YUVDataInfo &yuvinfo) 252 { 253 yuvDataInfo_ = yuvinfo; 254 } 255 NATIVEEXPORT virtual void AssignYuvDataOnType(PixelFormat format, int32_t width, int32_t height); 256 NATIVEEXPORT virtual void UpdateYUVDataInfo(PixelFormat format, int32_t width, int32_t height, 257 YUVStrideInfo &strides); GetImageYUVInfo(YUVDataInfo & yuvInfo)258 NATIVEEXPORT virtual void GetImageYUVInfo(YUVDataInfo &yuvInfo) const 259 { 260 yuvInfo = yuvDataInfo_; 261 } 262 #ifdef IMAGE_COLORSPACE_FLAG 263 // -------[inner api for ImageSource/ImagePacker codec] it will get a colorspace object pointer----begin---- 264 NATIVEEXPORT void InnerSetColorSpace(const OHOS::ColorManager::ColorSpace &grColorSpace, bool direct = false); 265 NATIVEEXPORT OHOS::ColorManager::ColorSpace InnerGetGrColorSpace(); InnerGetGrColorSpacePtr()266 NATIVEEXPORT std::shared_ptr<OHOS::ColorManager::ColorSpace> InnerGetGrColorSpacePtr() 267 { 268 return grColorSpace_; 269 } 270 NATIVEEXPORT virtual uint32_t ApplyColorSpace(const OHOS::ColorManager::ColorSpace &grColorSpace); 271 // -------[inner api for ImageSource/ImagePacker codec] it will get a colorspace object pointer----end------- 272 #endif 273 274 #ifdef IMAGE_PURGEABLE_PIXELMAP IsPurgeable()275 NATIVEEXPORT bool IsPurgeable() const 276 { 277 return purgeableMemPtr_ != nullptr; 278 } 279 GetPurgeableMemPtr()280 NATIVEEXPORT std::shared_ptr<PurgeableMem::PurgeableMemBase> GetPurgeableMemPtr() const 281 { 282 return purgeableMemPtr_; 283 } 284 SetPurgeableMemPtr(std::shared_ptr<PurgeableMem::PurgeableMemBase> pmPtr)285 NATIVEEXPORT void SetPurgeableMemPtr(std::shared_ptr<PurgeableMem::PurgeableMemBase> pmPtr) 286 { 287 purgeableMemPtr_ = pmPtr; 288 } 289 #endif 290 IsAstc()291 NATIVEEXPORT bool IsAstc() 292 { 293 return isAstc_; 294 } 295 SetAstc(bool isAstc)296 NATIVEEXPORT void SetAstc(bool isAstc) 297 { 298 isAstc_ = isAstc; 299 } 300 GetExifMetadata()301 NATIVEEXPORT std::shared_ptr<ExifMetadata> GetExifMetadata() 302 { 303 return exifMetadata_; 304 } 305 SetExifMetadata(std::shared_ptr<ExifMetadata> & ptr)306 NATIVEEXPORT void SetExifMetadata(std::shared_ptr<ExifMetadata> &ptr) 307 { 308 exifMetadata_ = ptr; 309 } 310 GetHdrMetadata()311 NATIVEEXPORT std::shared_ptr<HdrMetadata> GetHdrMetadata() 312 { 313 return hdrMetadata_; 314 } 315 SetHdrMetadata(const std::shared_ptr<HdrMetadata> & metadata)316 NATIVEEXPORT void SetHdrMetadata(const std::shared_ptr<HdrMetadata> &metadata) 317 { 318 hdrMetadata_ = metadata; 319 } 320 GetHdrType()321 NATIVEEXPORT ImageHdrType GetHdrType() 322 { 323 return hdrType_; 324 } 325 SetHdrType(ImageHdrType hdrType)326 NATIVEEXPORT void SetHdrType(ImageHdrType hdrType) 327 { 328 hdrType_ = hdrType; 329 } 330 331 NATIVEEXPORT uint32_t GetImagePropertyInt(const std::string &key, int32_t &value); 332 NATIVEEXPORT uint32_t GetImagePropertyString(const std::string &key, std::string &value); 333 NATIVEEXPORT uint32_t ModifyImageProperty(const std::string &key, const std::string &value); 334 NATIVEEXPORT uint32_t SetMemoryName(std::string pixelMapName); 335 336 NATIVEEXPORT bool IsHdr(); 337 NATIVEEXPORT uint32_t ToSdr(); 338 // format support rgba8888, nv12, nv21. The default value is rgba8888 339 // If toSRGB is false, pixelmap will be converted to display_p3 340 NATIVEEXPORT uint32_t ToSdr(PixelFormat format, bool toSRGB); 341 // use for hdr pixelmap, If isSRGB is false, the colorspace is p3 when converting to SDR. 342 NATIVEEXPORT void SetToSdrColorSpaceIsSRGB(bool isSRGB); 343 NATIVEEXPORT bool GetToSdrColorSpaceIsSRGB(); 344 SetAllocatorType(AllocatorType allocatorType)345 NATIVEEXPORT void SetAllocatorType(AllocatorType allocatorType) 346 { 347 allocatorType_ = allocatorType; 348 } 349 350 // unmap方案, 减少RenderService内存占用 351 NATIVEEXPORT bool UnMap(); 352 NATIVEEXPORT bool ReMap(); IsUnMap()353 NATIVEEXPORT bool IsUnMap() 354 { 355 std::lock_guard<std::mutex> lock(*unmapMutex_); 356 return isUnMap_; 357 } IncreaseUseCount()358 NATIVEEXPORT void IncreaseUseCount() 359 { 360 std::lock_guard<std::mutex> lock(*unmapMutex_); 361 useCount_ += 1; 362 } DecreaseUseCount()363 NATIVEEXPORT void DecreaseUseCount() 364 { 365 std::lock_guard<std::mutex> lock(*unmapMutex_); 366 if (useCount_ > 0) { 367 useCount_ -= 1; 368 } 369 } ResetUseCount()370 NATIVEEXPORT void ResetUseCount() 371 { 372 std::lock_guard<std::mutex> lock(*unmapMutex_); 373 useCount_ = 0; 374 } GetUseCount()375 NATIVEEXPORT uint64_t GetUseCount() 376 { 377 std::lock_guard<std::mutex> lock(*unmapMutex_); 378 return useCount_; 379 } GetUnMapCount()380 NATIVEEXPORT uint64_t GetUnMapCount() 381 { 382 std::lock_guard<std::mutex> lock(*unmapMutex_); 383 return unMapCount_; 384 } 385 386 // pixelmap with DMA memory should be marked dirty when memory was changed MarkDirty()387 NATIVEEXPORT void MarkDirty() 388 { 389 isMemoryDirty_ = true; 390 } 391 IsMemoryDirty()392 NATIVEEXPORT bool IsMemoryDirty() 393 { 394 return isMemoryDirty_; 395 } 396 397 static int32_t GetRGBxRowDataSize(const ImageInfo& info); 398 static int32_t GetRGBxByteCount(const ImageInfo& info); 399 static int32_t GetYUVByteCount(const ImageInfo& info); 400 static int32_t GetAllocatedByteCount(const ImageInfo& info); setAllocatorType(AllocatorType allocatorType)401 NATIVEEXPORT void setAllocatorType(AllocatorType allocatorType) 402 { 403 allocatorType_ = allocatorType; 404 } 405 406 protected: 407 static constexpr uint8_t TLV_VARINT_BITS = 7; 408 static constexpr uint8_t TLV_VARINT_MASK = 0x7F; 409 static constexpr uint8_t TLV_VARINT_MORE = 0x80; 410 static constexpr uint8_t TLV_END = 0x00; 411 static constexpr uint8_t TLV_IMAGE_WIDTH = 0x01; 412 static constexpr uint8_t TLV_IMAGE_HEIGHT = 0x02; 413 static constexpr uint8_t TLV_IMAGE_PIXELFORMAT = 0x03; 414 static constexpr uint8_t TLV_IMAGE_COLORSPACE = 0x04; 415 static constexpr uint8_t TLV_IMAGE_ALPHATYPE = 0x05; 416 static constexpr uint8_t TLV_IMAGE_BASEDENSITY = 0x06; 417 static constexpr uint8_t TLV_IMAGE_ALLOCATORTYPE = 0x07; 418 static constexpr uint8_t TLV_IMAGE_DATA = 0x08; 419 static constexpr size_t MAX_IMAGEDATA_SIZE = 128 * 1024 * 1024; // 128M 420 static constexpr size_t MIN_IMAGEDATA_SIZE = 32 * 1024; // 32k 421 friend class ImageSource; 422 friend class OHOS::Rosen::RSMarshallingHelper; 423 static bool ALPHA8ToARGB(const uint8_t *in, uint32_t inCount, uint32_t *out, uint32_t outCount); 424 static bool RGB565ToARGB(const uint8_t *in, uint32_t inCount, uint32_t *out, uint32_t outCount); 425 static bool ARGB8888ToARGB(const uint8_t *in, uint32_t inCount, uint32_t *out, uint32_t outCount); 426 static bool RGBA8888ToARGB(const uint8_t *in, uint32_t inCount, uint32_t *out, uint32_t outCount); 427 static bool BGRA8888ToARGB(const uint8_t *in, uint32_t inCount, uint32_t *out, uint32_t outCount); 428 static bool RGB888ToARGB(const uint8_t *in, uint32_t inCount, uint32_t *out, uint32_t outCount); 429 static bool CheckParams(const uint32_t *colors, uint32_t colorLength, int32_t offset, int32_t stride, 430 const InitializationOptions &opts); 431 static void UpdatePixelsAlpha(const AlphaType &alphaType, const PixelFormat &pixelFormat, uint8_t *dstPixels, 432 PixelMap &dstPixelMap); 433 static void InitDstImageInfo(const InitializationOptions &opts, const ImageInfo &srcImageInfo, 434 ImageInfo &dstImageInfo); 435 static bool CopyPixMapToDst(PixelMap &source, void* &dstPixels, int &fd, uint32_t bufferSize); 436 static bool CopyPixelMap(PixelMap &source, PixelMap &dstPixelMap, int32_t &error); 437 static bool CopyPixelMap(PixelMap &source, PixelMap &dstPixelMap); 438 static bool SourceCropAndConvert(PixelMap &source, const ImageInfo &srcImageInfo, const ImageInfo &dstImageInfo, 439 const Rect &srcRect, PixelMap &dstPixelMap); 440 static bool IsSameSize(const Size &src, const Size &dst); 441 static bool ScalePixelMap(const Size &targetSize, const Size &dstSize, const ScaleMode &scaleMode, 442 PixelMap &dstPixelMap); 443 static bool IsYuvFormat(PixelFormat format); 444 bool GetPixelFormatDetail(const PixelFormat format); 445 uint32_t CheckAlphaFormatInput(PixelMap &wPixelMap, const bool isPremul); 446 bool CheckPixelsInput(const uint8_t *dst, const uint64_t &bufferSize, const uint32_t &offset, 447 const uint32_t &stride, const Rect ®ion); 448 void ReleaseSharedMemory(void *addr, void *context, uint32_t size); 449 static void ReleaseBuffer(AllocatorType allocatorType, int fd, uint64_t dataSize, void **buffer); 450 static void *AllocSharedMemory(const uint64_t bufferSize, int &fd, uint32_t uniqueId); 451 bool WritePropertiesToParcel(Parcel &parcel) const; 452 bool ReadPropertiesFromParcel(Parcel &parcel, ImageInfo &imgInfo, AllocatorType &allocatorType, 453 int32_t &bufferSize, PIXEL_MAP_ERR &error); 454 bool WriteMemInfoToParcel(Parcel &parcel, const int32_t &bufferSize) const; 455 static bool ReadMemInfoFromParcel(Parcel &parcel, PixelMemInfo &pixelMemInfo, PIXEL_MAP_ERR &error); 456 bool WriteTransformDataToParcel(Parcel &parcel) const; 457 bool ReadTransformData(Parcel &parcel, PixelMap *pixelMap); 458 bool WriteAstcRealSizeToParcel(Parcel &parcel) const; 459 bool ReadAstcRealSize(Parcel &parcel, PixelMap *pixelMap); 460 bool WriteYuvDataInfoToParcel(Parcel &parcel) const; 461 bool ReadYuvDataInfoFromParcel(Parcel &parcel, PixelMap *pixelMap); 462 uint32_t SetRowDataSizeForImageInfo(ImageInfo info); SetEditable(bool editable)463 void SetEditable(bool editable) 464 { 465 editable_ = editable; 466 } 467 ResetPixelMap()468 void ResetPixelMap() 469 { 470 rowDataSize_ = 0; 471 pixelBytes_ = 0; 472 colorProc_ = nullptr; 473 } 474 CheckValidParam(int32_t x,int32_t y)475 bool CheckValidParam(int32_t x, int32_t y) 476 { 477 return isUnMap_ || data_ == nullptr || x >= imageInfo_.size.width || x < 0 || y >= imageInfo_.size.height || 478 y < 0 || (pixelsSize_ < static_cast<uint64_t>(rowDataSize_) * imageInfo_.size.height) ? false : true; 479 } 480 481 static void ReleaseMemory(AllocatorType allocType, void *addr, void *context, uint32_t size); 482 static bool UpdatePixelMapMemInfo(PixelMap *pixelMap, ImageInfo &imgInfo, PixelMemInfo &pixelMemInfo); 483 bool WriteImageData(Parcel &parcel, size_t size) const; 484 bool WriteAshmemDataToParcel(Parcel &parcel, size_t size) const; 485 static uint8_t *ReadImageData(Parcel &parcel, int32_t size); 486 static uint8_t *ReadHeapDataFromParcel(Parcel &parcel, int32_t bufferSize); 487 static uint8_t *ReadAshmemDataFromParcel(Parcel &parcel, int32_t bufferSize); 488 static int ReadFileDescriptor(Parcel &parcel); 489 static bool WriteFileDescriptor(Parcel &parcel, int fd); 490 static bool ReadImageInfo(Parcel &parcel, ImageInfo &imgInfo); 491 bool WriteImageInfo(Parcel &parcel) const; 492 void WriteUint8(std::vector<uint8_t> &buff, uint8_t value) const; 493 static uint8_t ReadUint8(std::vector<uint8_t> &buff, int32_t &cursor); 494 uint8_t GetVarintLen(int32_t value) const; 495 void WriteVarint(std::vector<uint8_t> &buff, int32_t value) const; 496 static int32_t ReadVarint(std::vector<uint8_t> &buff, int32_t &cursor); 497 void WriteData(std::vector<uint8_t> &buff, const uint8_t *data, 498 const int32_t &height, const int32_t &rowDataSize, const int32_t &rowStride) const; 499 static uint8_t *ReadData(std::vector<uint8_t> &buff, int32_t size, int32_t &cursor); 500 static void ReadTlvAttr(std::vector<uint8_t> &buff, ImageInfo &info, int32_t &type, int32_t &size, uint8_t **data); 501 bool DoTranslation(TransInfos &infos, const AntiAliasingOption &option = AntiAliasingOption::NONE); 502 void UpdateImageInfo(); 503 bool IsYuvFormat() const; 504 static int32_t ConvertPixelAlpha(const void *srcPixels, const int32_t srcLength, const ImageInfo &srcInfo, 505 void *dstPixels, const ImageInfo &dstInfo); 506 // used to close fd after mmap in RenderService when memory type is shared-mem or dma. 507 bool CloseFd(); 508 509 uint8_t *data_ = nullptr; 510 // this info SHOULD be the final info for decoded pixelmap, not the original image info 511 ImageInfo imageInfo_; 512 int32_t rowDataSize_ = 0; 513 int32_t rowStride_ = 0; 514 int32_t pixelBytes_ = 0; 515 TransColorProc colorProc_ = nullptr; 516 void *context_ = nullptr; 517 CustomFreePixelMap custFreePixelMap_ = nullptr; 518 CustomFreePixelMap freePixelMapProc_ = nullptr; 519 AllocatorType allocatorType_ = AllocatorType::SHARE_MEM_ALLOC; 520 uint32_t pixelsSize_ = 0; 521 bool editable_ = false; 522 bool modifiable_ = true; // If this is set to false, any modifications to the pixels data is not allowed 523 bool useSourceAsResponse_ = false; 524 bool isTransformered_ = false; 525 std::shared_ptr<std::mutex> transformMutex_ = std::make_shared<std::mutex>(); 526 527 // only used by rosen backend 528 uint32_t uniqueId_ = 0; 529 bool isAstc_ = false; 530 TransformData transformData_ = {1, 1, 0, 0, 0, 0, 0, 0, 0, false, false}; 531 Size astcrealSize_; 532 std::shared_ptr<HdrMetadata> hdrMetadata_ = nullptr; 533 ImageHdrType hdrType_; 534 535 #ifdef IMAGE_COLORSPACE_FLAG 536 std::shared_ptr<OHOS::ColorManager::ColorSpace> grColorSpace_ = nullptr; 537 #else 538 std::shared_ptr<uint8_t> grColorSpace_ = nullptr; 539 #endif 540 541 #ifdef IMAGE_PURGEABLE_PIXELMAP 542 std::shared_ptr<PurgeableMem::PurgeableMemBase> purgeableMemPtr_ = nullptr; 543 #else 544 std::shared_ptr<uint8_t> purgeableMemPtr_ = nullptr; 545 #endif 546 YUVDataInfo yuvDataInfo_; 547 std::shared_ptr<ExifMetadata> exifMetadata_ = nullptr; 548 std::shared_ptr<std::mutex> metadataMutex_ = std::make_shared<std::mutex>(); 549 std::shared_ptr<std::mutex> translationMutex_ = std::make_shared<std::mutex>(); 550 bool toSdrColorIsSRGB_ = false; 551 private: 552 // unmap方案, 减少RenderService内存占用 553 bool isUnMap_ = false; 554 uint64_t useCount_ = 0ULL; 555 uint64_t unMapCount_ = 0; 556 std::shared_ptr<std::mutex> unmapMutex_ = std::make_shared<std::mutex>(); 557 558 // used to mark whether DMA memory should be refreshed 559 mutable bool isMemoryDirty_; 560 }; 561 } // namespace Media 562 } // namespace OHOS 563 564 #endif // INTERFACES_INNERKITS_INCLUDE_PIXEL_MAP_H_ 565