diff --git a/frameworks/innerkitsimpl/codec/src/image_source.cpp b/frameworks/innerkitsimpl/codec/src/image_source.cpp
index 4814fa7e067b1dfd043bc57510b1369306433e8c..957e7082a3fd79c7900c8feb98e56ff5181fc2b5 100644
--- a/frameworks/innerkitsimpl/codec/src/image_source.cpp
+++ b/frameworks/innerkitsimpl/codec/src/image_source.cpp
@@ -32,9 +32,11 @@
 #include "incremental_source_stream.h"
 #include "istream_source_stream.h"
 #include "media_errors.h"
+#include "pixel_astc.h"
 #include "pixel_map.h"
 #include "plugin_server.h"
 #include "post_proc.h"
+#include "securec.h"
 #include "source_stream.h"
 #if defined(A_PLATFORM) || defined(IOS_PLATFORM)
 #include "include/jpeg_decoder.h"
@@ -61,7 +63,8 @@ static const map<PixelFormat, PlPixelFormat> PIXEL_FORMAT_MAP = {
     { PixelFormat::RGBA_F16, PlPixelFormat::RGBA_F16 },   { PixelFormat::RGBA_8888, PlPixelFormat::RGBA_8888 },
     { PixelFormat::BGRA_8888, PlPixelFormat::BGRA_8888 }, { PixelFormat::RGB_888, PlPixelFormat::RGB_888 },
     { PixelFormat::NV21, PlPixelFormat::NV21 },           { PixelFormat::NV12, PlPixelFormat::NV12 },
-    { PixelFormat::CMYK, PlPixelFormat::CMYK }
+    { PixelFormat::CMYK, PlPixelFormat::CMYK },           { PixelFormat::ASTC_4x4, PlPixelFormat::ASTC_4X4},
+    { PixelFormat::ASTC_6x6, PlPixelFormat::ASTC_6X6},    { PixelFormat::ASTC_8x8, PlPixelFormat::ASTC_8X8}
 };
 
 static const map<ColorSpace, PlColorSpace> COLOR_SPACE_MAP = {
@@ -86,6 +89,7 @@ static const map<ColorSpace, PlColorSpace> COLOR_SPACE_MAP = {
 
 namespace InnerFormat {
     const string RAW_FORMAT = "image/x-raw";
+    const string ASTC_FORMAT = "image/astc";
     const string EXTENDED_FORMAT = "image/x-skia";
     const string IMAGE_EXTENDED_CODEC = "image/extended";
     const string RAW_EXTENDED_FORMATS[] = {
@@ -113,7 +117,10 @@ static const uint8_t NUM_1 = 1;
 static const uint8_t NUM_2 = 2;
 static const uint8_t NUM_3 = 3;
 static const uint8_t NUM_4 = 4;
+static const uint8_t NUM_6 = 6;
+static const uint8_t NUM_8 = 8;
 static const int DMA_SIZE = 512;
+static const uint32_t ASTC_MAGIC_ID = 0x5CA1A813;
 
 PluginServer &ImageSource::pluginServer_ = ImageUtils::GetPluginServer();
 ImageSource::FormatAgentMap ImageSource::formatAgentMap_ = InitClass();
@@ -281,6 +288,10 @@ unique_ptr<PixelMap> ImageSource::CreatePixelMapEx(uint32_t index, const DecodeO
     IMAGE_LOGD("[ImageSource]CreatePixelMapEx srcPixelFormat:%{public}d, srcSize:(%{public}d, %{public}d)",
         sourceOptions_.pixelFormat, sourceOptions_.size.width, sourceOptions_.size.height);
 
+    if (IsASTC(sourceStreamPtr_->GetDataPtr())) {
+        return CreatePixelMapForASTC(errorCode);
+    }
+
     if (IsSpecialYUV()) {
         return CreatePixelMapForYUV(errorCode);
     }
@@ -1280,54 +1291,35 @@ uint32_t ImageSource::OnSourceRecognized(bool isAcquiredImageNum)
 uint32_t ImageSource::OnSourceUnresolved()
 {
     string formatResult;
-    auto ret = GetEncodedFormat(sourceInfo_.encodedFormat, formatResult);
-    if (ret != SUCCESS) {
-        if (ret == ERR_IMAGE_SOURCE_DATA_INCOMPLETE) {
-            IMAGE_LOGE("[ImageSource]image source incomplete.");
-            sourceInfo_.state = SourceInfoState::SOURCE_INCOMPLETE;
-            return ERR_IMAGE_SOURCE_DATA_INCOMPLETE;
-        } else if (ret == ERR_IMAGE_UNKNOWN_FORMAT) {
-            IMAGE_LOGE("[ImageSource]image unknown format.");
-            sourceInfo_.state = SourceInfoState::UNKNOWN_FORMAT;
-            decodeState_ = SourceDecodingState::UNKNOWN_FORMAT;
-            return ERR_IMAGE_UNKNOWN_FORMAT;
+    if (IsASTC(sourceStreamPtr_->GetDataPtr())) {
+        formatResult = InnerFormat::ASTC_FORMAT;
+    } else {
+        auto ret = GetEncodedFormat(sourceInfo_.encodedFormat, formatResult);
+        if (ret != SUCCESS) {
+            if (ret == ERR_IMAGE_SOURCE_DATA_INCOMPLETE) {
+                IMAGE_LOGE("[ImageSource]image source incomplete.");
+                sourceInfo_.state = SourceInfoState::SOURCE_INCOMPLETE;
+                return ERR_IMAGE_SOURCE_DATA_INCOMPLETE;
+            } else if (ret == ERR_IMAGE_UNKNOWN_FORMAT) {
+                IMAGE_LOGE("[ImageSource]image unknown format.");
+                sourceInfo_.state = SourceInfoState::UNKNOWN_FORMAT;
+                decodeState_ = SourceDecodingState::UNKNOWN_FORMAT;
+                return ERR_IMAGE_UNKNOWN_FORMAT;
+            }
+            sourceInfo_.state = SourceInfoState::SOURCE_ERROR;
+            decodeState_ = SourceDecodingState::SOURCE_ERROR;
+            IMAGE_LOGE("[ImageSource]image source error.");
+            return ret;
         }
-        sourceInfo_.state = SourceInfoState::SOURCE_ERROR;
-        decodeState_ = SourceDecodingState::SOURCE_ERROR;
-        IMAGE_LOGE("[ImageSource]image source error.");
-        return ret;
     }
     sourceInfo_.encodedFormat = formatResult;
     decodeState_ = SourceDecodingState::FORMAT_RECOGNIZED;
     return SUCCESS;
 }
 
-uint32_t ImageSource::DecodeSourceInfo(bool isAcquiredImageNum)
+uint32_t GetSourceDecodingState(SourceDecodingState decodeState_)
 {
     uint32_t ret = SUCCESS;
-    if (decodeState_ >= SourceDecodingState::FILE_INFO_DECODED) {
-        if (isAcquiredImageNum) {
-            decodeState_ = SourceDecodingState::FORMAT_RECOGNIZED;
-        } else {
-            return SUCCESS;
-        }
-    }
-    if (decodeState_ == SourceDecodingState::UNRESOLVED) {
-        ret = OnSourceUnresolved();
-        if (ret != SUCCESS) {
-            IMAGE_LOGE("[ImageSource]unresolved source: check format failed, ret:[%{public}d].", ret);
-            return ret;
-        }
-    }
-    if (decodeState_ == SourceDecodingState::FORMAT_RECOGNIZED) {
-        ret = OnSourceRecognized(isAcquiredImageNum);
-        if (ret != SUCCESS) {
-            IMAGE_LOGE("[ImageSource]recognized source: get source info failed, ret:[%{public}d].", ret);
-            return ret;
-        }
-        return SUCCESS;
-    }
-    IMAGE_LOGE("[ImageSource]invalid source state %{public}d on decode source info.", decodeState_);
     switch (decodeState_) {
         case SourceDecodingState::SOURCE_ERROR: {
             ret = ERR_IMAGE_SOURCE_DATA;
@@ -1353,6 +1345,41 @@ uint32_t ImageSource::DecodeSourceInfo(bool isAcquiredImageNum)
     return ret;
 }
 
+uint32_t ImageSource::DecodeSourceInfo(bool isAcquiredImageNum)
+{
+    uint32_t ret = SUCCESS;
+    if (decodeState_ >= SourceDecodingState::FILE_INFO_DECODED) {
+        if (isAcquiredImageNum) {
+            decodeState_ = SourceDecodingState::FORMAT_RECOGNIZED;
+        } else {
+            return SUCCESS;
+        }
+    }
+    if (decodeState_ == SourceDecodingState::UNRESOLVED) {
+        ret = OnSourceUnresolved();
+        if (ret != SUCCESS) {
+            IMAGE_LOGE("[ImageSource]unresolved source: check format failed, ret:[%{public}d].", ret);
+            return ret;
+        }
+    }
+    if (decodeState_ == SourceDecodingState::FORMAT_RECOGNIZED) {
+        if (sourceInfo_.encodedFormat == InnerFormat::ASTC_FORMAT) {
+            sourceInfo_.state = SourceInfoState::FILE_INFO_PARSED;
+            decodeState_ = SourceDecodingState::FILE_INFO_DECODED;
+        } else {
+            ret = OnSourceRecognized(isAcquiredImageNum);
+            if (ret != SUCCESS) {
+                IMAGE_LOGE("[ImageSource]recognized source: get source info failed, ret:[%{public}d].", ret);
+                return ret;
+            }
+        }
+        return SUCCESS;
+    }
+    IMAGE_LOGE("[ImageSource]invalid source state %{public}d on decode source info.", decodeState_);
+    ret = GetSourceDecodingState(decodeState_);
+    return ret;
+}
+
 uint32_t ImageSource::DecodeImageInfo(uint32_t index, ImageStatusMap::iterator &iter)
 {
     uint32_t ret = DecodeSourceInfo(false);
@@ -1360,6 +1387,16 @@ uint32_t ImageSource::DecodeImageInfo(uint32_t index, ImageStatusMap::iterator &
         IMAGE_LOGE("[ImageSource]decode the image fail, ret:%{public}d.", ret);
         return ret;
     }
+    if (sourceInfo_.encodedFormat == InnerFormat::ASTC_FORMAT) {
+        ASTCInfo astcInfo = GetASTCInfo(sourceStreamPtr_->GetDataPtr());
+        ImageDecodingStatus imageStatus;
+        imageStatus.imageInfo.size.width = astcInfo.size.width;
+        imageStatus.imageInfo.size.height = astcInfo.size.height;
+        imageStatus.imageState = ImageDecodingState::BASE_INFO_PARSED;
+        auto result = imageStatusMap_.insert(ImageStatusMap::value_type(index, imageStatus));
+        iter = result.first;
+        return SUCCESS;
+    }
     if (mainDecoder_ == nullptr) {
         IMAGE_LOGE("[ImageSource]get image size, image decode plugin is null.");
         return ERR_IMAGE_PLUGIN_CREATE_FAILED;
@@ -1885,6 +1922,104 @@ unique_ptr<PixelMap> ImageSource::CreatePixelMapForYUV(uint32_t &errorCode)
     return pixelMap;
 }
 
+bool ImageSource::IsASTC(const uint8_t *fileData)
+{
+    unsigned int magicVal = static_cast<unsigned int>(fileData[0]) + (static_cast<unsigned int>(fileData[1]) << 8) +
+        (static_cast<unsigned int>(fileData[2]) << 16) + (static_cast<unsigned int>(fileData[3]) << 24);
+    return magicVal == ASTC_MAGIC_ID;
+}
+
+ImageInfo ImageSource::GetImageInfoForASTC()
+{
+    ImageInfo info;
+    ASTCInfo astcInfo = GetASTCInfo(sourceStreamPtr_->GetDataPtr());
+    info.size.width = astcInfo.size.width;
+    info.size.height = astcInfo.size.height;
+    switch (astcInfo.blockFootprint.width) {
+        case NUM_4: {
+            info.pixelFormat = PixelFormat::ASTC_4x4;
+            break;
+        }
+        case NUM_6: {
+            info.pixelFormat = PixelFormat::ASTC_6x6;
+            break;
+        }
+        case NUM_8: {
+            info.pixelFormat = PixelFormat::ASTC_8x8;
+            break;
+        }
+        default:
+            info.pixelFormat = PixelFormat::UNKNOWN;
+    }
+    return info;
+}
+
+unique_ptr<PixelMap> ImageSource::CreatePixelMapForASTC(uint32_t &errorCode)
+{
+    trace(BEGIN_TRACE, "CreatePixelMapForASTC");
+    unique_ptr<PixelAstc> pixelAstc = make_unique<PixelAstc>();
+    if (pixelAstc == nullptr) {
+        IMAGE_LOGE("[ImageSource]create the pixelmap unique_ptr fail.");
+        errorCode = ERR_IMAGE_MALLOC_ABNORMAL;
+        return nullptr;
+    }
+
+    ImageInfo info = GetImageInfoForASTC();
+    errorCode = pixelAstc->SetImageInfo(info);
+    if (errorCode != SUCCESS) {
+        IMAGE_LOGE("[ImageSource]update pixelmap info error ret:%{public}u.", errorCode);
+        return nullptr;
+    }
+    pixelAstc->SetEditable(false);
+    size_t fileSize = sourceStreamPtr_->GetStreamSize();
+    if (sourceStreamPtr_->GetStreamType() == ImagePlugin::FILE_STREAM_TYPE) {
+        void *fdBuffer = new int32_t();
+        *static_cast<int32_t *>(fdBuffer) = static_cast<FileSourceStream *>(sourceStreamPtr_.get())->GetMMapFd();
+        pixelAstc->SetPixelsAddr(sourceStreamPtr_->GetDataPtr(), fdBuffer, fileSize,
+            AllocatorType::SHARE_MEM_ALLOC, nullptr);
+    } else if (sourceStreamPtr_->GetStreamType() == ImagePlugin::BUFFER_SOURCE_TYPE) {
+        int fd = AshmemCreate("CreatePixelMapForASTC Data", fileSize);
+        if (fd < 0) {
+            IMAGE_LOGE("[ImageSource]CreatePixelMapForASTC AshmemCreate fd < 0.");
+            return nullptr;
+        }
+        int result = AshmemSetProt(fd, PROT_READ | PROT_WRITE);
+        if (result < 0) {
+            IMAGE_LOGE("[ImageSource]CreatePixelMapForASTC AshmemSetPort error.");
+            ::close(fd);
+            return nullptr;
+        }
+        void* ptr = ::mmap(nullptr, fileSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+        if (ptr == MAP_FAILED || ptr == nullptr) {
+            IMAGE_LOGE("[ImageSource]CreatePixelMapForASTC data is nullptr.");
+            ::close(fd);
+            return nullptr;
+        }
+        auto data = static_cast<uint8_t*>(ptr);
+        void* fdPtr = new int32_t();
+        *static_cast<int32_t*>(fdPtr) = fd;
+        pixelAstc->SetPixelsAddr(data, fdPtr, fileSize, Media::AllocatorType::SHARE_MEM_ALLOC, nullptr);
+        memcpy_s(data, fileSize, sourceStreamPtr_->GetDataPtr(), fileSize);
+    }
+    pixelAstc->SetAstc(true);
+    trace(FINISH_TRACE);
+    return pixelAstc;
+}
+
+ASTCInfo ImageSource::GetASTCInfo(const uint8_t *fileData)
+{
+    uint32_t width = static_cast<unsigned int>(fileData[7]) + (static_cast<unsigned int>(fileData[8]) << 8) +
+        (static_cast<unsigned int>(fileData[9]) << 16);
+    uint32_t height = static_cast<unsigned int>(fileData[10]) + (static_cast<unsigned int>(fileData[11]) << 8) +
+        (static_cast<unsigned int>(fileData[12]) << 16);
+    uint32_t blockWidth = fileData[4];
+    uint32_t blockHeight = fileData[5];
+    return {
+        .size = {.width = width, .height = height},
+        .blockFootprint = {.width = blockWidth, .height = blockHeight}
+    };
+}
+
 unique_ptr<vector<unique_ptr<PixelMap>>> ImageSource::CreatePixelMapList(const DecodeOptions &opts,
     uint32_t &errorCode)
 {
diff --git a/frameworks/innerkitsimpl/common/include/pixel_map_utils.h b/frameworks/innerkitsimpl/common/include/pixel_map_utils.h
index 872a06ccd64581b9bcc88baa7f27f1b5d68cf568..58974d753870749a91dc8b091e465ea081af5f49 100644
--- a/frameworks/innerkitsimpl/common/include/pixel_map_utils.h
+++ b/frameworks/innerkitsimpl/common/include/pixel_map_utils.h
@@ -29,6 +29,7 @@ constexpr int8_t RGB_888_BYTES = 3;
 constexpr int8_t ARGB_8888_BYTES = 4;
 constexpr int8_t BGRA_F16_BYTES = 8;
 constexpr int8_t YUV420_BYTES = 2;  // in fact NV21 one pixel used 1.5 bytes.
+constexpr int8_t ASTC_4x4_BYTES = 1;
 
 // Define shift bits of bytes per pixel
 constexpr int8_t ALPHA_8_SHIFT = 0;
diff --git a/frameworks/innerkitsimpl/common/src/pixel_astc.cpp b/frameworks/innerkitsimpl/common/src/pixel_astc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ac9b2e2e33bd8e95b9e5e77b79bb53289390c64c
--- /dev/null
+++ b/frameworks/innerkitsimpl/common/src/pixel_astc.cpp
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "pixel_astc.h"
+
+#include "image_utils.h"
+#include "image_trace.h"
+#include "image_type_converter.h"
+#include "memory_manager.h"
+#include "include/core/SkBitmap.h"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkImage.h"
+#include "hilog/log.h"
+#include "hitrace_meter.h"
+#include "log_tags.h"
+#include "media_errors.h"
+#include "pubdef.h"
+
+namespace OHOS {
+namespace Media {
+using namespace OHOS::HiviewDFX;
+using namespace std;
+constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, LOG_TAG_DOMAIN_ID_IMAGE, "PixelAstc" };
+
+PixelAstc::~PixelAstc()
+{
+    HiLog::Info(LABEL, "PixelAstc destory");
+    FreePixelMap();
+}
+
+const uint8_t *PixelAstc::GetPixel8(int32_t x, int32_t y)
+{
+    HiLog::Error(LABEL, "GetPixel8 is not support on pixelastc");
+    return nullptr;
+}
+
+const uint16_t *PixelAstc::GetPixel16(int32_t x, int32_t y)
+{
+    HiLog::Error(LABEL, "GetPixel16 is not support on pixelastc");
+    return nullptr;
+}
+
+const uint32_t *PixelAstc::GetPixel32(int32_t x, int32_t y)
+{
+    HiLog::Error(LABEL, "GetPixel32 is not support on pixelastc");
+    return nullptr;
+}
+
+bool PixelAstc::GetARGB32Color(int32_t x, int32_t y, uint32_t &color)
+{
+    HiLog::Error(LABEL, "GetARGB32Color is not support on pixelastc");
+    return false;
+}
+
+void PixelAstc::scale(float xAxis, float yAxis)
+{
+    HiLog::Error(LABEL, "scale is not support on pixelastc");
+}
+
+bool PixelAstc::resize(float xAxis, float yAxis)
+{
+    HiLog::Error(LABEL, "resize is not support on pixelastc");
+    return false;
+}
+
+void PixelAstc::translate(float xAxis, float yAxis)
+{
+    HiLog::Error(LABEL, "translate is not support on pixelastc");
+}
+
+void PixelAstc::rotate(float degrees)
+{
+    HiLog::Error(LABEL, "rotate is not support on pixelastc");
+}
+
+void PixelAstc::flip(bool xAxis, bool yAxis)
+{
+    HiLog::Error(LABEL, "flip is not support on pixelastc");
+}
+
+uint32_t PixelAstc::crop(const Rect &rect)
+{
+    HiLog::Error(LABEL, "crop is not support on pixelastc");
+    return ERR_IMAGE_CROP;
+}
+
+uint32_t PixelAstc::SetAlpha(const float percent)
+{
+    HiLog::Error(LABEL, "SetAlpha is not support on pixelastc");
+    return ERR_IMAGE_DATA_UNSUPPORT;
+}
+
+uint8_t PixelAstc::GetARGB32ColorA(uint32_t color)
+{
+    HiLog::Error(LABEL, "GetARGB32ColorA is not support on pixelastc");
+    return 0;
+}
+
+uint8_t PixelAstc::GetARGB32ColorR(uint32_t color)
+{
+    HiLog::Error(LABEL, "GetARGB32ColorR is not support on pixelastc");
+    return 0;
+}
+
+uint8_t PixelAstc::GetARGB32ColorG(uint32_t color)
+{
+    HiLog::Error(LABEL, "GetARGB32ColorG is not support on pixelastc");
+    return 0;
+}
+
+uint8_t PixelAstc::GetARGB32ColorB(uint32_t color)
+{
+    HiLog::Error(LABEL, "GetARGB32ColorB is not support on pixelastc");
+    return 0;
+}
+
+bool PixelAstc::IsSameImage(const PixelMap &other)
+{
+    HiLog::Error(LABEL, "IsSameImage is not support on pixelastc");
+    return false;
+}
+
+uint32_t PixelAstc::ReadPixels(const uint64_t &bufferSize, const uint32_t &offset, const uint32_t &stride,
+                               const Rect &region, uint8_t *dst)
+{
+    HiLog::Error(LABEL, "ReadPixels is not support on pixelastc");
+    return ERR_IMAGE_INVALID_PARAMETER;
+}
+
+uint32_t PixelAstc::ReadPixels(const uint64_t &bufferSize, uint8_t *dst)
+{
+    HiLog::Error(LABEL, "ReadPixels is not support on pixelastc");
+    return ERR_IMAGE_INVALID_PARAMETER;
+}
+
+uint32_t PixelAstc::ReadPixel(const Position &pos, uint32_t &dst)
+{
+    HiLog::Error(LABEL, "ReadPixel is not support on pixelastc");
+    return ERR_IMAGE_INVALID_PARAMETER;
+}
+
+uint32_t PixelAstc::ResetConfig(const Size &size, const PixelFormat &format)
+{
+    HiLog::Error(LABEL, "ResetConfig is not support on pixelastc");
+    return ERR_IMAGE_INVALID_PARAMETER;
+}
+
+bool PixelAstc::SetAlphaType(const AlphaType &alphaType)
+{
+    HiLog::Error(LABEL, "SetAlphaType is not support on pixelastc");
+    return false;
+}
+
+uint32_t PixelAstc::WritePixel(const Position &pos, const uint32_t &color)
+{
+    HiLog::Error(LABEL, "WritePixel is not support on pixelastc");
+    return ERR_IMAGE_INVALID_PARAMETER;
+}
+
+uint32_t PixelAstc::WritePixels(const uint8_t *source, const uint64_t &bufferSize, const uint32_t &offset,
+                                const uint32_t &stride, const Rect &region)
+{
+    HiLog::Error(LABEL, "WritePixels is not support on pixelastc");
+    return ERR_IMAGE_INVALID_PARAMETER;
+}
+
+uint32_t PixelAstc::WritePixels(const uint8_t *source, const uint64_t &bufferSize)
+{
+    HiLog::Error(LABEL, "WritePixels is not support on pixelastc");
+    return ERR_IMAGE_INVALID_PARAMETER;
+}
+
+bool PixelAstc::WritePixels(const uint32_t &color)
+{
+    HiLog::Error(LABEL, "WritePixels is not support on pixelastc");
+    return false;
+}
+
+void PixelAstc::SetTransformered(bool isTransformered)
+{
+    HiLog::Error(LABEL, "SetTransformered is not support on pixelastc");
+}
+
+bool PixelAstc::IsTransformered()
+{
+    HiLog::Error(LABEL, "IsTransformered is not support on pixelastc");
+    return false;
+}
+
+void PixelAstc::SetRowStride(uint32_t stride)
+{
+    HiLog::Error(LABEL, "SetRowStride is not support on pixelastc");
+}
+
+int32_t PixelAstc::GetRowStride()
+{
+    HiLog::Error(LABEL, "GetRowStride is not support on pixelastc");
+    return 0;
+}
+
+bool PixelAstc::IsSourceAsResponse()
+{
+    HiLog::Error(LABEL, "IsSourceAsResponse is not support on pixelastc");
+    return false;
+}
+
+void* PixelAstc::GetWritablePixels() const
+{
+    HiLog::Error(LABEL, "GetWritablePixels is not support on pixelastc");
+    return nullptr;
+}
+} // namespace Media
+} // namespace OHOS
\ No newline at end of file
diff --git a/frameworks/innerkitsimpl/common/src/pixel_map.cpp b/frameworks/innerkitsimpl/common/src/pixel_map.cpp
index c92ae51736eea0d94806d1095076524bb1737393..817dd818fdd23d9cdb26cb90d3f5f3d52202fa40 100644
--- a/frameworks/innerkitsimpl/common/src/pixel_map.cpp
+++ b/frameworks/innerkitsimpl/common/src/pixel_map.cpp
@@ -71,6 +71,12 @@ constexpr uint8_t PER_PIXEL_LEN = 1;
 constexpr uint8_t FILL_NUMBER = 3;
 constexpr uint8_t ALIGN_NUMBER = 4;
 
+static const uint8_t NUM_2 = 2;
+static const uint8_t NUM_3 = 3;
+static const uint8_t NUM_5 = 5;
+static const uint8_t NUM_6 = 6;
+static const uint8_t NUM_7 = 7;
+
 constexpr int32_t AntiAliasingSize = 350;
 PixelMap::~PixelMap()
 {
@@ -669,6 +675,11 @@ bool PixelMap::GetPixelFormatDetail(const PixelFormat format)
         case PixelFormat::RGBA_F16:
             pixelBytes_ = BGRA_F16_BYTES;
             break;
+        case PixelFormat::ASTC_4x4:
+        case PixelFormat::ASTC_6x6:
+        case PixelFormat::ASTC_8x8:
+            pixelBytes_ = ASTC_4x4_BYTES;
+            break;
         default: {
             HiLog::Error(LABEL, "pixel format:[%{public}d] not supported.", format);
             return false;
@@ -692,6 +703,36 @@ uint32_t PixelMap::SetImageInfo(ImageInfo &info)
     return SetImageInfo(info, false);
 }
 
+uint32_t PixelMap::SetRowDataSizeForImageInfo(ImageInfo info)
+{
+    if (info.pixelFormat == PixelFormat::ALPHA_8) {
+        rowDataSize_ = pixelBytes_ * ((info.size.width + FILL_NUMBER) / ALIGN_NUMBER * ALIGN_NUMBER);
+        SetRowStride(rowDataSize_);
+        HiLog::Info(LABEL, "ALPHA_8 rowDataSize_ %{public}d.", rowDataSize_);
+    } else if (info.pixelFormat == PixelFormat::ASTC_4x4) {
+        rowDataSize_ = pixelBytes_ * (((info.size.width + NUM_3) >> NUM_2) << NUM_2);
+    } else if (info.pixelFormat == PixelFormat::ASTC_6x6) {
+        rowDataSize_ = pixelBytes_ * (((info.size.width + NUM_5) / NUM_6) * NUM_6);
+    } else if (info.pixelFormat == PixelFormat::ASTC_8x8) {
+        rowDataSize_ = pixelBytes_ * (((info.size.width + NUM_7) >> NUM_3) << NUM_3);
+    } else {
+#if !defined(IOS_PLATFORM) && !defined(A_PLATFORM)
+        if (allocatorType_ == AllocatorType::DMA_ALLOC) {
+            if (context_ == nullptr) {
+                HiLog::Error(LABEL, "set imageInfo context_ null");
+                return ERR_IMAGE_DATA_ABNORMAL;
+            }
+            SurfaceBuffer* sbBuffer = reinterpret_cast<SurfaceBuffer*>(context_);
+            SetRowStride(sbBuffer->GetStride());
+        } else {
+            SetRowStride(pixelBytes_ * info.size.width);
+        }
+#endif
+        rowDataSize_ = pixelBytes_ * info.size.width;
+    }
+    return SUCCESS;
+}
+
 uint32_t PixelMap::SetImageInfo(ImageInfo &info, bool isReused)
 {
     if (info.size.width <= 0 || info.size.height <= 0) {
@@ -713,25 +754,12 @@ uint32_t PixelMap::SetImageInfo(ImageInfo &info, bool isReused)
         HiLog::Error(LABEL, "image size is out of range.");
         return ERR_IMAGE_TOO_LARGE;
     }
-    if (info.pixelFormat == PixelFormat::ALPHA_8) {
-        rowDataSize_ = pixelBytes_ * ((info.size.width + FILL_NUMBER) / ALIGN_NUMBER * ALIGN_NUMBER);
-        SetRowStride(rowDataSize_);
-        HiLog::Info(LABEL, "ALPHA_8 rowDataSize_ %{public}d.", rowDataSize_);
-    } else {
-#if !defined(IOS_PLATFORM) && !defined(A_PLATFORM)
-        if (allocatorType_ == AllocatorType::DMA_ALLOC) {
-            if (context_ == nullptr) {
-                HiLog::Error(LABEL, "set imageInfo context_ null");
-                return ERR_IMAGE_DATA_ABNORMAL;
-            }
-            SurfaceBuffer* sbBuffer = reinterpret_cast<SurfaceBuffer*>(context_);
-            SetRowStride(sbBuffer->GetStride());
-        } else {
-            SetRowStride(pixelBytes_ * info.size.width);
-        }
-#endif
-        rowDataSize_ = pixelBytes_ * info.size.width;
+
+    if (SetRowDataSizeForImageInfo(info) != SUCCESS) {
+        HiLog::Error(LABEL, "pixel map set rowDataSize error.");
+        return ERR_IMAGE_DATA_ABNORMAL;
     }
+
     if (rowDataSize_ != 0 && info.size.height > (PIXEL_MAP_MAX_RAM_SIZE / rowDataSize_)) {
         ResetPixelMap();
         HiLog::Error(LABEL, "pixel map byte count out of range.");
@@ -1566,6 +1594,11 @@ bool PixelMap::WriteInfoToParcel(Parcel &parcel) const
         return false;
     }
 
+    if (!parcel.WriteBool(isAstc_)) {
+        HiLog::Error(LABEL, "write pixel map isAstc_ to parcel failed.");
+        return false;
+    }
+
     if (!parcel.WriteInt32(static_cast<int32_t>(allocatorType_))) {
         HiLog::Error(LABEL, "write pixel map allocator type:[%{public}d] to parcel failed.",
                      allocatorType_);
@@ -1578,6 +1611,9 @@ bool PixelMap::Marshalling(Parcel &parcel) const
 {
     int32_t PIXEL_MAP_INFO_MAX_LENGTH = 128;
     int32_t bufferSize = rowDataSize_ * imageInfo_.size.height;
+    if (isAstc_) {
+        bufferSize = pixelsSize_;
+    }
     if (static_cast<size_t>(bufferSize) <= MIN_IMAGEDATA_SIZE &&
         static_cast<size_t>(bufferSize + PIXEL_MAP_INFO_MAX_LENGTH) > parcel.GetDataCapacity() &&
         !parcel.SetDataCapacity(bufferSize + PIXEL_MAP_INFO_MAX_LENGTH)) {
@@ -1661,7 +1697,10 @@ PixelMap *PixelMap::Unmarshalling(Parcel &parcel)
 
     bool isEditable = parcel.ReadBool();
     pixelMap->SetEditable(isEditable);
-    
+
+    bool isAstc = parcel.ReadBool();
+    pixelMap->SetAstc(isAstc);
+
     AllocatorType allocType = static_cast<AllocatorType>(parcel.ReadInt32());
     int32_t rowDataSize = parcel.ReadInt32();
     int32_t bufferSize = parcel.ReadInt32();
@@ -1671,7 +1710,7 @@ PixelMap *PixelMap::Unmarshalling(Parcel &parcel)
         HiLog::Error(LABEL, "unmarshalling get bytes by per pixel fail.");
         return nullptr;
     }
-    if (bufferSize != rowDataSize * imgInfo.size.height) {
+    if ((!isAstc) && bufferSize != rowDataSize * imgInfo.size.height) {
         delete pixelMap;
         HiLog::Error(LABEL, "unmarshalling bufferSize parcelling error");
         return nullptr;
@@ -1988,6 +2027,12 @@ static const string GetNamedPixelFormat(const PixelFormat pixelFormat)
             return "Pixel Format BGRA_8888";
         case PixelFormat::RGBA_F16:
             return "Pixel Format RGBA_F16";
+        case PixelFormat::ASTC_4x4:
+            return "Pixel Format ASTC_4x4";
+        case PixelFormat::ASTC_6x6:
+            return "Pixel Format ASTC_6x6";
+        case PixelFormat::ASTC_8x8:
+            return "Pixel Format ASTC_8x8";
         default:
             return "Pixel Format UNKNOWN";
     }
diff --git a/frameworks/innerkitsimpl/stream/include/buffer_packer_stream.h b/frameworks/innerkitsimpl/stream/include/buffer_packer_stream.h
index bc2ef5b8c9ac42fd2c1ddcc78ff6c9d74243e4ee..6d3066e9e0e28255dc77ced96bd2dba49fc15629 100644
--- a/frameworks/innerkitsimpl/stream/include/buffer_packer_stream.h
+++ b/frameworks/innerkitsimpl/stream/include/buffer_packer_stream.h
@@ -32,6 +32,15 @@ public:
     int64_t BytesWritten() override;
     bool GetCapicity(size_t &size) override;
 
+    uint8_t* GetAddr() const override
+    {
+        return outputData_;
+    }
+
+    void SetOffset(uint32_t offset) override
+    {
+        offset_ = offset;
+    }
 private:
     DISALLOW_COPY(BufferPackerStream);
     static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {
diff --git a/frameworks/innerkitsimpl/stream/include/file_source_stream.h b/frameworks/innerkitsimpl/stream/include/file_source_stream.h
index fc8bf7fc44329069d2bf0a700c760eae7fc6c164..879fdd738a8b2037557f970740b6320c0f5a653e 100644
--- a/frameworks/innerkitsimpl/stream/include/file_source_stream.h
+++ b/frameworks/innerkitsimpl/stream/include/file_source_stream.h
@@ -40,6 +40,7 @@ public:
     uint8_t *GetDataPtr() override;
     uint32_t GetStreamType() override;
     ImagePlugin::OutputDataStream* ToOutputDataStream() override;
+    int GetMMapFd();
 
 private:
     DISALLOW_COPY_AND_MOVE(FileSourceStream);
@@ -53,6 +54,8 @@ private:
     size_t fileOriginalOffset_ = 0;
     uint8_t *readBuffer_ = nullptr;
     uint8_t *fileData_ = nullptr;
+    int mmapFd_ = -1;
+    bool mmapFdPassedOn_ = false;
 };
 } // namespace Media
 } // namespace OHOS
diff --git a/frameworks/innerkitsimpl/stream/src/file_source_stream.cpp b/frameworks/innerkitsimpl/stream/src/file_source_stream.cpp
index c191f3b68bd719bbf1b0ff9cedc1683ff4e2c754..ca6cd6f8b22d5578117f4aa4ad04dd5cb17acbeb 100644
--- a/frameworks/innerkitsimpl/stream/src/file_source_stream.cpp
+++ b/frameworks/innerkitsimpl/stream/src/file_source_stream.cpp
@@ -270,16 +270,14 @@ uint8_t *FileSourceStream::GetDataPtr()
         return fileData_;
     }
 #ifdef SUPPORT_MMAP
-    int dupFd = -1;
-    if (!DupFd(filePtr_, dupFd)) {
+    if (!DupFd(filePtr_, mmapFd_)) {
         return nullptr;
     }
-    auto mmptr = ::mmap(nullptr, fileSize_, PROT_READ, MAP_SHARED, dupFd, 0);
+    auto mmptr = ::mmap(nullptr, fileSize_, PROT_READ, MAP_SHARED, mmapFd_, 0);
     if (mmptr == MAP_FAILED) {
         HiLog::Error(LABEL, "[FileSourceStream] mmap failed, errno:%{public}d", errno);
         return nullptr;
     }
-    close(dupFd);
     fileData_ = static_cast<uint8_t*>(mmptr);
 #endif
     return fileData_;
@@ -296,12 +294,13 @@ void FileSourceStream::ResetReadBuffer()
         free(readBuffer_);
         readBuffer_ = nullptr;
     }
-    if (fileData_ != nullptr) {
+    if (fileData_ != nullptr && !mmapFdPassedOn_) {
 #ifdef SUPPORT_MMAP
         ::munmap(fileData_, fileSize_);
-        fileData_ = nullptr;
+        close(mmapFd_);
 #endif
     }
+    fileData_ = nullptr;
 }
 
 OutputDataStream* FileSourceStream::ToOutputDataStream()
@@ -313,5 +312,11 @@ OutputDataStream* FileSourceStream::ToOutputDataStream()
     }
     return new (std::nothrow) FilePackerStream(dupFd);
 }
+
+int FileSourceStream::GetMMapFd()
+{
+    mmapFdPassedOn_ = true;
+    return mmapFd_;
+}
 } // namespace Media
 } // namespace OHOS
diff --git a/frameworks/innerkitsimpl/utils/src/image_utils.cpp b/frameworks/innerkitsimpl/utils/src/image_utils.cpp
index f78c9204881c8fb44f12461261f5cde6ee8561d0..530d3a506ca01bb47a9d82706031899674c3837d 100644
--- a/frameworks/innerkitsimpl/utils/src/image_utils.cpp
+++ b/frameworks/innerkitsimpl/utils/src/image_utils.cpp
@@ -52,6 +52,7 @@ constexpr int32_t RGB888_BYTES = 3;
 constexpr int32_t ARGB8888_BYTES = 4;
 constexpr int32_t RGBA_F16_BYTES = 8;
 constexpr int32_t NV21_BYTES = 2;  // Each pixel is sorted on 3/2 bytes.
+constexpr int32_t ASTC_4x4_BYTES = 1;
 constexpr float EPSILON = 1e-6;
 constexpr int MAX_DIMENSION = INT32_MAX >> 2;
 static bool g_pluginRegistered = false;
@@ -133,6 +134,11 @@ int32_t ImageUtils::GetPixelBytes(const PixelFormat &pixelFormat)
         case PixelFormat::NV12:
             pixelBytes = NV21_BYTES;  // perl pixel 1.5 Bytes but return int so return 2
             break;
+        case PixelFormat::ASTC_4x4:
+        case PixelFormat::ASTC_6x6:
+        case PixelFormat::ASTC_8x8:
+            pixelBytes = ASTC_4x4_BYTES;
+            break;
         default:
             IMAGE_LOGE("[ImageUtil]get pixel bytes failed, pixelFormat:%{public}d.", static_cast<int32_t>(pixelFormat));
             break;
diff --git a/interfaces/innerkits/BUILD.gn b/interfaces/innerkits/BUILD.gn
index 7cd7c5d6eb6f1b9e2feb7490ba59d2c4bad6b448..33467fa9e888355ea1cbe13f418e0e4d32830092 100644
--- a/interfaces/innerkits/BUILD.gn
+++ b/interfaces/innerkits/BUILD.gn
@@ -136,6 +136,7 @@ if (use_clang_android) {
     sources = [
       "${image_subsystem}/frameworks/innerkitsimpl/common/src/memory_manager.cpp",
       "${image_subsystem}/frameworks/innerkitsimpl/common/src/native_image.cpp",
+      "${image_subsystem}/frameworks/innerkitsimpl/common/src/pixel_astc.cpp",
       "//foundation/multimedia/image_framework/frameworks/innerkitsimpl/codec/src/image_packer.cpp",
       "//foundation/multimedia/image_framework/frameworks/innerkitsimpl/codec/src/image_packer_ex.cpp",
       "//foundation/multimedia/image_framework/frameworks/innerkitsimpl/codec/src/image_source.cpp",
@@ -238,6 +239,7 @@ ohos_static_library("image_static") {
   public_configs = [ ":image_external_config" ]
 
   sources = [
+    "${image_subsystem}/frameworks/innerkitsimpl/common/src/pixel_astc.cpp",
     "//foundation/multimedia/image_framework/frameworks/innerkitsimpl/codec/src/image_packer.cpp",
     "//foundation/multimedia/image_framework/frameworks/innerkitsimpl/codec/src/image_packer_ex.cpp",
     "//foundation/multimedia/image_framework/frameworks/innerkitsimpl/codec/src/image_source.cpp",
diff --git a/interfaces/innerkits/include/image_source.h b/interfaces/innerkits/include/image_source.h
index 17cc35aedb4eb4658a795b6a9e635d5e473c89f9..d84f798495a1d975d6dc33e41885f3cea8d4cad4 100644
--- a/interfaces/innerkits/include/image_source.h
+++ b/interfaces/innerkits/include/image_source.h
@@ -129,6 +129,11 @@ struct PixelMapAddrInfos {
     CustomFreePixelMap func;
 };
 
+struct ASTCInfo {
+    Size size;
+    Size blockFootprint;
+};
+
 class SourceStream;
 
 class ImageSource {
@@ -145,6 +150,9 @@ public:
                                                        uint32_t &errorCode);
     NATIVEEXPORT static std::unique_ptr<ImageSource> CreateIncrementalImageSource(const IncrementalSourceOptions &opts,
                                                                                   uint32_t &errorCode);
+    NATIVEEXPORT static bool IsASTC(const uint8_t *fileData);
+
+    NATIVEEXPORT static ASTCInfo GetASTCInfo(const uint8_t *fileData);
 
     NATIVEEXPORT std::unique_ptr<PixelMap> CreatePixelMap(const DecodeOptions &opts, uint32_t &errorCode)
     {
@@ -235,8 +243,10 @@ private:
     static std::unique_ptr<SourceStream> DecodeBase64(const uint8_t *data, uint32_t size);
     static std::unique_ptr<SourceStream> DecodeBase64(const std::string &data);
     bool IsSpecialYUV();
+    ImageInfo GetImageInfoForASTC();
     bool ConvertYUV420ToRGBA(uint8_t *data, uint32_t size, bool isSupportOdd, bool isAddUV, uint32_t &errorCode);
     std::unique_ptr<PixelMap> CreatePixelMapForYUV(uint32_t &errorCode);
+    std::unique_ptr<PixelMap> CreatePixelMapForASTC(uint32_t &errorCode);
     uint32_t GetFormatExtended(std::string &format);
     static std::unique_ptr<ImageSource> DoImageSourceCreate(
         std::function<std::unique_ptr<SourceStream>(void)> stream,
diff --git a/interfaces/innerkits/include/image_type.h b/interfaces/innerkits/include/image_type.h
index 476d16f9e90fdb02b05e156fb9ba6b479d99f883..f88a843a161d1a0554f7b60e263bc6f72218235f 100644
--- a/interfaces/innerkits/include/image_type.h
+++ b/interfaces/innerkits/include/image_type.h
@@ -108,6 +108,9 @@ enum class PixelFormat : int32_t {
     NV21 = 8,  // Each pixel is sorted on 3/2 bytes.
     NV12 = 9,
     CMYK = 10,
+    ASTC_4x4 = 11,
+    ASTC_6x6 = 12,
+    ASTC_8x8 = 13,
 };
 
 enum class AlphaType : int32_t {
diff --git a/interfaces/innerkits/include/pixel_astc.h b/interfaces/innerkits/include/pixel_astc.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f4e57de8581d7533fd4ef23dce827c48811cf6c
--- /dev/null
+++ b/interfaces/innerkits/include/pixel_astc.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INTERFACES_INNERKITS_INCLUDE_PIXEL_ASTC_H_
+#define INTERFACES_INNERKITS_INCLUDE_PIXEL_ASTC_H_
+
+#include "pixel_map.h"
+
+namespace OHOS {
+namespace Media {
+typedef struct {
+    uint8_t magic[4];
+    uint8_t blockdimX;
+    uint8_t blockdimY;
+    uint8_t blockdimZ;
+    uint8_t xsize[3];
+    uint8_t ysize[3];
+    uint8_t zsize[3];
+} AstcHeader;
+
+class PixelAstc : public PixelMap {
+public:
+    PixelAstc()
+    {
+        static std::atomic<uint32_t> currentId = 0;
+        astcId_ = currentId.fetch_add(1, std::memory_order_relaxed);
+    }
+    virtual ~PixelAstc();
+
+    NATIVEEXPORT uint32_t SetAlpha(const float percent) override;
+    NATIVEEXPORT bool SetAlphaType(const AlphaType &alphaType) override;
+    NATIVEEXPORT void SetTransformered(bool isTransformered) override;
+    NATIVEEXPORT void SetRowStride(uint32_t stride) override;
+
+    NATIVEEXPORT const uint8_t *GetPixel8(int32_t x, int32_t y) override;
+    NATIVEEXPORT const uint16_t *GetPixel16(int32_t x, int32_t y) override;
+    NATIVEEXPORT const uint32_t *GetPixel32(int32_t x, int32_t y) override;
+    NATIVEEXPORT bool GetARGB32Color(int32_t x, int32_t y, uint32_t &color) override;
+    NATIVEEXPORT uint8_t GetARGB32ColorA(uint32_t color) override;
+    NATIVEEXPORT uint8_t GetARGB32ColorR(uint32_t color) override;
+    NATIVEEXPORT uint8_t GetARGB32ColorG(uint32_t color) override;
+    NATIVEEXPORT uint8_t GetARGB32ColorB(uint32_t color) override;
+    NATIVEEXPORT int32_t GetRowStride() override;
+    NATIVEEXPORT void *GetWritablePixels() const override;
+    NATIVEEXPORT uint32_t GetUniqueId() const override
+    {
+        return astcId_;
+    }
+
+    NATIVEEXPORT void scale(float xAxis, float yAxis) override;
+    NATIVEEXPORT bool resize(float xAxis, float yAxis) override;
+    NATIVEEXPORT void translate(float xAxis, float yAxis) override;
+    NATIVEEXPORT void rotate(float degrees) override;
+    NATIVEEXPORT void flip(bool xAxis, bool yAxis) override;
+    NATIVEEXPORT uint32_t crop(const Rect &rect) override;
+
+    // Config the pixel map parameter
+    NATIVEEXPORT bool IsSameImage(const PixelMap &other) override;
+    NATIVEEXPORT bool IsTransformered() override;
+    // judgement whether create pixelmap use source as result
+    NATIVEEXPORT bool IsSourceAsResponse() override;
+
+    NATIVEEXPORT uint32_t ReadPixels(const uint64_t &bufferSize, const uint32_t &offset, const uint32_t &stride,
+                                     const Rect &region, uint8_t *dst) override;
+    NATIVEEXPORT uint32_t ReadPixels(const uint64_t &bufferSize, uint8_t *dst) override;
+    NATIVEEXPORT uint32_t ReadPixel(const Position &pos, uint32_t &dst) override;
+    NATIVEEXPORT uint32_t ResetConfig(const Size &size, const PixelFormat &format) override;
+    NATIVEEXPORT uint32_t WritePixel(const Position &pos, const uint32_t &color) override;
+    NATIVEEXPORT uint32_t WritePixels(const uint8_t *source, const uint64_t &bufferSize, const uint32_t &offset,
+                         const uint32_t &stride, const Rect &region) override;
+    NATIVEEXPORT uint32_t WritePixels(const uint8_t *source, const uint64_t &bufferSize) override;
+    NATIVEEXPORT bool WritePixels(const uint32_t &color) override;
+
+private:
+    uint32_t astcId_ = 0;
+};
+} // namespace Media
+} // namespace OHOS
+
+#endif // INTERFACES_INNERKITS_INCLUDE_PIXEL_ASTC_H_
\ No newline at end of file
diff --git a/interfaces/innerkits/include/pixel_map.h b/interfaces/innerkits/include/pixel_map.h
index ea34aea2b16a3ef7b1afa9ccea633e5c332f6ba6..e6fec8f11e8cfc95930d3037a89787c8f531b488 100644
--- a/interfaces/innerkits/include/pixel_map.h
+++ b/interfaces/innerkits/include/pixel_map.h
@@ -73,95 +73,95 @@ public:
     NATIVEEXPORT static std::unique_ptr<PixelMap> Create(PixelMap &source, const InitializationOptions &opts);
     NATIVEEXPORT static std::unique_ptr<PixelMap> Create(PixelMap &source, const Rect &srcRect,
                                                          const InitializationOptions &opts);
-    NATIVEEXPORT uint32_t SetImageInfo(ImageInfo &info);
-    NATIVEEXPORT uint32_t SetImageInfo(ImageInfo &info, bool isReused);
-    NATIVEEXPORT const uint8_t *GetPixel(int32_t x, int32_t y);
-    NATIVEEXPORT const uint8_t *GetPixel8(int32_t x, int32_t y);
-    NATIVEEXPORT const uint16_t *GetPixel16(int32_t x, int32_t y);
-    NATIVEEXPORT const uint32_t *GetPixel32(int32_t x, int32_t y);
-    NATIVEEXPORT bool GetARGB32Color(int32_t x, int32_t y, uint32_t &color);
-    NATIVEEXPORT void SetPixelsAddr(void *addr, void *context, uint32_t size, AllocatorType type,
+    NATIVEEXPORT virtual uint32_t SetImageInfo(ImageInfo &info);
+    NATIVEEXPORT virtual uint32_t SetImageInfo(ImageInfo &info, bool isReused);
+    NATIVEEXPORT virtual const uint8_t *GetPixel(int32_t x, int32_t y);
+    NATIVEEXPORT virtual const uint8_t *GetPixel8(int32_t x, int32_t y);
+    NATIVEEXPORT virtual const uint16_t *GetPixel16(int32_t x, int32_t y);
+    NATIVEEXPORT virtual const uint32_t *GetPixel32(int32_t x, int32_t y);
+    NATIVEEXPORT virtual bool GetARGB32Color(int32_t x, int32_t y, uint32_t &color);
+    NATIVEEXPORT virtual void SetPixelsAddr(void *addr, void *context, uint32_t size, AllocatorType type,
                                     CustomFreePixelMap func);
-    NATIVEEXPORT int32_t GetPixelBytes();
-    NATIVEEXPORT int32_t GetRowBytes();
-    NATIVEEXPORT int32_t GetByteCount();
-    NATIVEEXPORT int32_t GetWidth();
-    NATIVEEXPORT int32_t GetHeight();
-    NATIVEEXPORT int32_t GetBaseDensity();
-    NATIVEEXPORT void scale(float xAxis, float yAxis);
-    NATIVEEXPORT bool resize(float xAxis, float yAxis);
-    NATIVEEXPORT void translate(float xAxis, float yAxis);
-    NATIVEEXPORT void rotate(float degrees);
-    NATIVEEXPORT void flip(bool xAxis, bool yAxis);
-    NATIVEEXPORT uint32_t crop(const Rect &rect);
-    NATIVEEXPORT void GetImageInfo(ImageInfo &imageInfo);
-    NATIVEEXPORT PixelFormat GetPixelFormat();
-    NATIVEEXPORT ColorSpace GetColorSpace();
-    NATIVEEXPORT AlphaType GetAlphaType();
-    NATIVEEXPORT uint32_t SetAlpha(const float percent);
-    NATIVEEXPORT const uint8_t *GetPixels();
-    NATIVEEXPORT uint8_t GetARGB32ColorA(uint32_t color);
-    NATIVEEXPORT uint8_t GetARGB32ColorR(uint32_t color);
-    NATIVEEXPORT uint8_t GetARGB32ColorG(uint32_t color);
-    NATIVEEXPORT uint8_t GetARGB32ColorB(uint32_t color);
+    NATIVEEXPORT virtual int32_t GetPixelBytes();
+    NATIVEEXPORT virtual int32_t GetRowBytes();
+    NATIVEEXPORT virtual int32_t GetByteCount();
+    NATIVEEXPORT virtual int32_t GetWidth();
+    NATIVEEXPORT virtual int32_t GetHeight();
+    NATIVEEXPORT virtual int32_t GetBaseDensity();
+    NATIVEEXPORT virtual void scale(float xAxis, float yAxis);
+    NATIVEEXPORT virtual bool resize(float xAxis, float yAxis);
+    NATIVEEXPORT virtual void translate(float xAxis, float yAxis);
+    NATIVEEXPORT virtual void rotate(float degrees);
+    NATIVEEXPORT virtual void flip(bool xAxis, bool yAxis);
+    NATIVEEXPORT virtual uint32_t crop(const Rect &rect);
+    NATIVEEXPORT virtual void GetImageInfo(ImageInfo &imageInfo);
+    NATIVEEXPORT virtual PixelFormat GetPixelFormat();
+    NATIVEEXPORT virtual ColorSpace GetColorSpace();
+    NATIVEEXPORT virtual AlphaType GetAlphaType();
+    NATIVEEXPORT virtual uint32_t SetAlpha(const float percent);
+    NATIVEEXPORT virtual const uint8_t *GetPixels();
+    NATIVEEXPORT virtual uint8_t GetARGB32ColorA(uint32_t color);
+    NATIVEEXPORT virtual uint8_t GetARGB32ColorR(uint32_t color);
+    NATIVEEXPORT virtual uint8_t GetARGB32ColorG(uint32_t color);
+    NATIVEEXPORT virtual uint8_t GetARGB32ColorB(uint32_t color);
     // Config the pixel map parameter
-    NATIVEEXPORT bool IsSameImage(const PixelMap &other);
-    NATIVEEXPORT uint32_t ReadPixels(const uint64_t &bufferSize, const uint32_t &offset, const uint32_t &stride,
+    NATIVEEXPORT virtual bool IsSameImage(const PixelMap &other);
+    NATIVEEXPORT virtual uint32_t ReadPixels(const uint64_t &bufferSize, const uint32_t &offset, const uint32_t &stride,
                                      const Rect &region, uint8_t *dst);
-    NATIVEEXPORT uint32_t ReadPixels(const uint64_t &bufferSize, uint8_t *dst);
-    NATIVEEXPORT uint32_t ReadPixel(const Position &pos, uint32_t &dst);
-    NATIVEEXPORT uint32_t ResetConfig(const Size &size, const PixelFormat &format);
-    NATIVEEXPORT bool SetAlphaType(const AlphaType &alphaType);
-    NATIVEEXPORT uint32_t WritePixel(const Position &pos, const uint32_t &color);
-    NATIVEEXPORT uint32_t WritePixels(const uint8_t *source, const uint64_t &bufferSize, const uint32_t &offset,
+    NATIVEEXPORT virtual uint32_t ReadPixels(const uint64_t &bufferSize, uint8_t *dst);
+    NATIVEEXPORT virtual uint32_t ReadPixel(const Position &pos, uint32_t &dst);
+    NATIVEEXPORT virtual uint32_t ResetConfig(const Size &size, const PixelFormat &format);
+    NATIVEEXPORT virtual bool SetAlphaType(const AlphaType &alphaType);
+    NATIVEEXPORT virtual uint32_t WritePixel(const Position &pos, const uint32_t &color);
+    NATIVEEXPORT virtual uint32_t WritePixels(const uint8_t *source, const uint64_t &bufferSize, const uint32_t &offset,
                          const uint32_t &stride, const Rect &region);
-    NATIVEEXPORT uint32_t WritePixels(const uint8_t *source, const uint64_t &bufferSize);
-    NATIVEEXPORT bool WritePixels(const uint32_t &color);
-    NATIVEEXPORT void FreePixelMap();
-    NATIVEEXPORT AllocatorType GetAllocatorType();
-    NATIVEEXPORT void *GetFd() const;
-    NATIVEEXPORT void SetFreePixelMapProc(CustomFreePixelMap func);
-    NATIVEEXPORT void SetTransformered(bool isTransformered);
+    NATIVEEXPORT virtual uint32_t WritePixels(const uint8_t *source, const uint64_t &bufferSize);
+    NATIVEEXPORT virtual bool WritePixels(const uint32_t &color);
+    NATIVEEXPORT virtual void FreePixelMap();
+    NATIVEEXPORT virtual AllocatorType GetAllocatorType();
+    NATIVEEXPORT virtual void *GetFd() const;
+    NATIVEEXPORT virtual void SetFreePixelMapProc(CustomFreePixelMap func);
+    NATIVEEXPORT virtual void SetTransformered(bool isTransformered);
 
-    NATIVEEXPORT void SetRowStride(uint32_t stride);
-    NATIVEEXPORT uint32_t GetRowStride()
+    NATIVEEXPORT virtual void SetRowStride(uint32_t stride);
+    NATIVEEXPORT virtual int32_t GetRowStride()
     {
         return rowStride_;
     }
-    NATIVEEXPORT uint32_t GetCapacity()
+    NATIVEEXPORT virtual uint32_t GetCapacity()
     {
         return pixelsSize_;
     }
 
-    NATIVEEXPORT bool IsEditable()
+    NATIVEEXPORT virtual bool IsEditable()
     {
         return editable_;
     }
 
-    NATIVEEXPORT bool IsTransformered()
+    NATIVEEXPORT virtual bool IsTransformered()
     {
         return isTransformered_;
     }
 
     // judgement whether create pixelmap use source as result
-    NATIVEEXPORT bool IsSourceAsResponse()
+    NATIVEEXPORT virtual bool IsSourceAsResponse()
     {
         return useSourceAsResponse_;
     }
 
-    NATIVEEXPORT void *GetWritablePixels() const
+    NATIVEEXPORT virtual void *GetWritablePixels() const
     {
         return static_cast<void *>(data_);
     }
 
-    NATIVEEXPORT uint32_t GetUniqueId() const
+    NATIVEEXPORT virtual uint32_t GetUniqueId() const
     {
         return uniqueId_;
     }
 
-    NATIVEEXPORT bool Marshalling(Parcel &data) const override;
+    NATIVEEXPORT virtual bool Marshalling(Parcel &data) const override;
     NATIVEEXPORT static PixelMap *Unmarshalling(Parcel &data);
-    NATIVEEXPORT bool EncodeTlv(std::vector<uint8_t> &buff) const;
+    NATIVEEXPORT virtual bool EncodeTlv(std::vector<uint8_t> &buff) const;
     NATIVEEXPORT static PixelMap *DecodeTlv(std::vector<uint8_t> &buff);
 
 #ifdef IMAGE_COLORSPACE_FLAG
@@ -192,6 +192,16 @@ public:
     }
 #endif
 
+    NATIVEEXPORT bool IsAstc()
+    {
+        return isAstc_;
+    }
+
+    NATIVEEXPORT void SetAstc(bool isAstc)
+    {
+        isAstc_ = isAstc;
+    }
+
 private:
     static constexpr uint8_t TLV_VARINT_BITS = 7;
     static constexpr uint8_t TLV_VARINT_MASK = 0x7F;
@@ -234,6 +244,7 @@ private:
     static void ReleaseBuffer(AllocatorType allocatorType, int fd, uint64_t dataSize, void **buffer);
     static void *AllocSharedMemory(const uint64_t bufferSize, int &fd, uint32_t uniqueId);
     bool WriteInfoToParcel(Parcel &parcel) const;
+    uint32_t SetRowDataSizeForImageInfo(ImageInfo info);
     void SetEditable(bool editable)
     {
         editable_ = editable;
@@ -291,6 +302,7 @@ private:
 
     // only used by rosen backend
     uint32_t uniqueId_ = 0;
+    bool isAstc_ = false;
 
 #ifdef IMAGE_COLORSPACE_FLAG
     std::shared_ptr<OHOS::ColorManager::ColorSpace> grColorSpace_ = nullptr;
diff --git a/plugins/manager/include/image/image_plugin_type.h b/plugins/manager/include/image/image_plugin_type.h
index 3f5fe1e9dfffa744b22c585cd883d76a86b44912..3e75b2fc59abcee2c5761a370c445f576b0d0883 100644
--- a/plugins/manager/include/image/image_plugin_type.h
+++ b/plugins/manager/include/image/image_plugin_type.h
@@ -93,6 +93,9 @@ enum class PlPixelFormat {
     NV21 = 8,
     NV12 = 9,
     CMYK = 10,
+    ASTC_4X4 = 11,
+    ASTC_6X6 = 12,
+    ASTC_8X8 = 13,
 };
 
 enum class PlAlphaType : int32_t {
diff --git a/plugins/manager/include/image/output_data_stream.h b/plugins/manager/include/image/output_data_stream.h
index 3c6b7b7e1c2c451b2a4054e590a397b5a1fea417..a07e8187193b642fe51fbd5d799608877bea8f72 100644
--- a/plugins/manager/include/image/output_data_stream.h
+++ b/plugins/manager/include/image/output_data_stream.h
@@ -34,6 +34,13 @@ public:
     {
         return false;
     }
+
+    virtual uint8_t* GetAddr() const
+    {
+        return nullptr;
+    }
+
+    virtual void SetOffset(uint32_t offset) {}
 };
 } // namespace ImagePlugin
 } // namespace OHOS