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