2019-11-23 20:27:39 +08:00
|
|
|
/****************************************************************************
|
|
|
|
Copyright (c) 2010-2012 cocos2d-x.org
|
|
|
|
Copyright (c) 2013-2016 Chukong Technologies Inc.
|
|
|
|
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
|
2022-04-25 19:15:46 +08:00
|
|
|
Copyright (c) 2020 C4games Ltd
|
2022-04-23 17:49:42 +08:00
|
|
|
Copyright (c) 2021-2022 Bytedance Inc.
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2022-07-09 22:23:34 +08:00
|
|
|
https://axis-project.github.io/
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
all copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
THE SOFTWARE.
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#include "platform/CCImage.h"
|
2022-04-27 18:24:33 +08:00
|
|
|
#include "renderer/backend/PixelFormatUtils.h"
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
#include <string>
|
|
|
|
#include <ctype.h>
|
|
|
|
|
2022-07-15 19:17:01 +08:00
|
|
|
#include "base/ccConfig.h" // AX_USE_JPEG, AX_USE_WEBP
|
2019-11-25 02:28:38 +08:00
|
|
|
|
|
|
|
#define STBI_NO_JPEG
|
|
|
|
#define STBI_NO_PNG
|
|
|
|
#define STBI_NO_GIF
|
|
|
|
#define STBI_NO_PSD
|
|
|
|
#define STBI_NO_PIC
|
|
|
|
#define STBI_NO_PNM
|
|
|
|
#define STBI_NO_HDR
|
|
|
|
#define STBI_NO_TGA
|
|
|
|
#define STB_IMAGE_IMPLEMENTATION
|
2022-07-15 19:17:01 +08:00
|
|
|
#if AX_TARGET_PLATFORM == AX_PLATFORM_IOS
|
2021-12-25 10:04:45 +08:00
|
|
|
# define STBI_NO_THREAD_LOCALS
|
2020-06-14 15:52:15 +08:00
|
|
|
#endif
|
2019-11-25 02:28:38 +08:00
|
|
|
#include "stb/stb_image.h"
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
extern "C" {
|
|
|
|
// To resolve link error when building 32bits with Xcode 6.
|
|
|
|
// More information please refer to the discussion in https://github.com/cocos2d/cocos2d-x/pull/6986
|
2022-07-15 19:17:01 +08:00
|
|
|
#if defined(__unix) || (AX_TARGET_PLATFORM == AX_PLATFORM_IOS)
|
2021-12-25 10:04:45 +08:00
|
|
|
# ifndef __ENABLE_COMPATIBILITY_WITH_UNIX_2003__
|
|
|
|
# define __ENABLE_COMPATIBILITY_WITH_UNIX_2003__
|
|
|
|
# include <stdio.h>
|
|
|
|
# include <dirent.h>
|
|
|
|
FILE* fopen$UNIX2003(const char* filename, const char* mode)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
return fopen(filename, mode);
|
|
|
|
}
|
|
|
|
size_t fwrite$UNIX2003(const void* a, size_t b, size_t c, FILE* d)
|
|
|
|
{
|
|
|
|
return fwrite(a, b, c, d);
|
|
|
|
}
|
|
|
|
int fputs$UNIX2003(const char* res1, FILE* res2)
|
|
|
|
{
|
|
|
|
return fputs(res1, res2);
|
|
|
|
}
|
|
|
|
char* strerror$UNIX2003(int errnum)
|
|
|
|
{
|
|
|
|
return strerror(errnum);
|
|
|
|
}
|
|
|
|
DIR* opendir$INODE64$UNIX2003(char* dirName)
|
|
|
|
{
|
|
|
|
return opendir(dirName);
|
|
|
|
}
|
|
|
|
DIR* opendir$INODE64(char* dirName)
|
|
|
|
{
|
|
|
|
return opendir(dirName);
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
int closedir$UNIX2003(DIR* dir)
|
|
|
|
{
|
|
|
|
return closedir(dir);
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
struct dirent* readdir$INODE64(DIR* dir)
|
|
|
|
{
|
|
|
|
return readdir(dir);
|
|
|
|
}
|
|
|
|
# endif
|
2019-11-23 20:27:39 +08:00
|
|
|
#endif
|
|
|
|
|
2022-07-15 19:17:01 +08:00
|
|
|
#if AX_USE_PNG
|
2021-12-25 10:04:45 +08:00
|
|
|
# include "png.h"
|
2022-07-15 19:17:01 +08:00
|
|
|
#endif // AX_USE_PNG
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2022-07-15 19:17:01 +08:00
|
|
|
#if AX_USE_JPEG
|
2021-12-25 10:04:45 +08:00
|
|
|
# include "jpeglib.h"
|
|
|
|
# include <setjmp.h>
|
2022-07-15 19:17:01 +08:00
|
|
|
#endif // AX_USE_JPEG
|
2022-01-04 11:00:07 +08:00
|
|
|
} /* extern "C" */
|
|
|
|
|
2022-04-25 19:11:58 +08:00
|
|
|
#include "base/ktxspec_v1.h"
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
#include "base/s3tc.h"
|
|
|
|
#include "base/atitc.h"
|
|
|
|
#include "base/pvr.h"
|
|
|
|
#include "base/TGAlib.h"
|
|
|
|
|
2022-01-04 11:00:07 +08:00
|
|
|
#include "base/etc1.h"
|
|
|
|
#include "base/etc2.h"
|
|
|
|
|
|
|
|
#include "base/astc.h"
|
|
|
|
|
2022-07-15 19:17:01 +08:00
|
|
|
#if AX_USE_WEBP
|
2021-12-25 10:04:45 +08:00
|
|
|
# include "decode.h"
|
2022-07-15 19:17:01 +08:00
|
|
|
#endif // AX_USE_WEBP
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
#include "base/ccMacros.h"
|
|
|
|
#include "platform/CCCommon.h"
|
|
|
|
#include "platform/CCStdC.h"
|
|
|
|
#include "platform/CCFileUtils.h"
|
|
|
|
#include "base/CCConfiguration.h"
|
|
|
|
#include "base/ccUtils.h"
|
|
|
|
#include "base/ZipUtils.h"
|
2022-07-15 19:17:01 +08:00
|
|
|
#if (AX_TARGET_PLATFORM == AX_PLATFORM_ANDROID)
|
2021-12-25 10:04:45 +08:00
|
|
|
# include "platform/android/CCFileUtils-android.h"
|
|
|
|
# include "platform/CCGL.h"
|
2019-11-23 20:27:39 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2022-07-11 17:50:21 +08:00
|
|
|
NS_AX_BEGIN
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
2021-12-25 10:04:45 +08:00
|
|
|
// struct and data for pvr structure
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
namespace
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
static const int PVR_TEXTURE_FLAG_TYPE_MASK = 0xff;
|
|
|
|
|
|
|
|
// Values taken from PVRTexture.h from http://www.imgtec.com
|
|
|
|
enum class PVR2TextureFlag
|
|
|
|
{
|
|
|
|
Mipmap = (1 << 8), // has mip map levels
|
|
|
|
Twiddle = (1 << 9), // is twiddled
|
|
|
|
Bumpmap = (1 << 10), // has normals encoded for a bump map
|
|
|
|
Tiling = (1 << 11), // is bordered for tiled pvr
|
|
|
|
Cubemap = (1 << 12), // is a cubemap/skybox
|
|
|
|
FalseMipCol = (1 << 13), // are there false colored MIP levels
|
|
|
|
Volume = (1 << 14), // is this a volume texture
|
|
|
|
Alpha = (1 << 15), // v2.1 is there transparency info in the texture
|
|
|
|
VerticalFlip = (1 << 16), // v2.1 is the texture vertically flipped
|
|
|
|
};
|
|
|
|
|
|
|
|
enum class PVR3TextureFlag
|
|
|
|
{
|
|
|
|
PremultipliedAlpha = (1 << 1) // has premultiplied alpha
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char gPVRTexIdentifier[5] = "PVR!";
|
|
|
|
|
|
|
|
// v2
|
|
|
|
enum class PVR2TexturePixelFormat : uint8_t
|
|
|
|
{
|
|
|
|
RGBA4444 = 0x10,
|
|
|
|
RGBA5551,
|
|
|
|
RGBA8888,
|
|
|
|
RGB565,
|
|
|
|
RGB555, // unsupported
|
|
|
|
RGB888,
|
|
|
|
I8,
|
|
|
|
AI88,
|
|
|
|
PVRTC2BPP_RGBA,
|
|
|
|
PVRTC4BPP_RGBA,
|
|
|
|
BGRA8888,
|
|
|
|
A8,
|
|
|
|
};
|
|
|
|
|
|
|
|
// v3
|
|
|
|
enum class PVR3TexturePixelFormat : uint64_t
|
|
|
|
{
|
|
|
|
PVRTC2BPP_RGB = 0ULL,
|
|
|
|
PVRTC2BPP_RGBA = 1ULL,
|
|
|
|
PVRTC4BPP_RGB = 2ULL,
|
|
|
|
PVRTC4BPP_RGBA = 3ULL,
|
|
|
|
PVRTC2_2BPP_RGBA = 4ULL,
|
|
|
|
PVRTC2_4BPP_RGBA = 5ULL,
|
|
|
|
ETC1 = 6ULL,
|
|
|
|
DXT1 = 7ULL,
|
|
|
|
DXT2 = 8ULL,
|
|
|
|
DXT3 = 9ULL,
|
|
|
|
DXT4 = 10ULL,
|
|
|
|
DXT5 = 11ULL,
|
|
|
|
BC1 = 7ULL,
|
|
|
|
BC2 = 9ULL,
|
|
|
|
BC3 = 11ULL,
|
|
|
|
BC4 = 12ULL,
|
|
|
|
BC5 = 13ULL,
|
|
|
|
BC6 = 14ULL,
|
|
|
|
BC7 = 15ULL,
|
|
|
|
UYVY = 16ULL,
|
|
|
|
YUY2 = 17ULL,
|
|
|
|
BW1bpp = 18ULL,
|
|
|
|
R9G9B9E5 = 19ULL,
|
|
|
|
RGBG8888 = 20ULL,
|
|
|
|
GRGB8888 = 21ULL,
|
|
|
|
ETC2_RGB = 22ULL,
|
|
|
|
ETC2_RGBA = 23ULL,
|
|
|
|
ETC2_RGBA1 = 24ULL,
|
|
|
|
EAC_R11_Unsigned = 25ULL,
|
|
|
|
EAC_R11_Signed = 26ULL,
|
|
|
|
EAC_RG11_Unsigned = 27ULL,
|
|
|
|
EAC_RG11_Signed = 28ULL,
|
|
|
|
|
|
|
|
BGRA8888 = 0x0808080861726762ULL,
|
|
|
|
RGBA8888 = 0x0808080861626772ULL,
|
|
|
|
RGBA4444 = 0x0404040461626772ULL,
|
|
|
|
RGBA5551 = 0x0105050561626772ULL,
|
|
|
|
RGB565 = 0x0005060500626772ULL,
|
|
|
|
RGB888 = 0x0008080800626772ULL,
|
|
|
|
A8 = 0x0000000800000061ULL,
|
|
|
|
L8 = 0x000000080000006cULL,
|
|
|
|
LA88 = 0x000008080000616cULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
// v2
|
|
|
|
typedef const std::map<PVR2TexturePixelFormat, backend::PixelFormat> _pixel2_formathash;
|
|
|
|
|
|
|
|
static const _pixel2_formathash::value_type v2_pixel_formathash_value[] = {
|
|
|
|
_pixel2_formathash::value_type(PVR2TexturePixelFormat::BGRA8888, backend::PixelFormat::BGRA8),
|
|
|
|
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA8888, backend::PixelFormat::RGBA8),
|
|
|
|
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA4444, backend::PixelFormat::RGBA4),
|
|
|
|
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA5551, backend::PixelFormat::RGB5A1),
|
|
|
|
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGB565, backend::PixelFormat::RGB565),
|
|
|
|
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGB888, backend::PixelFormat::RGB8),
|
|
|
|
_pixel2_formathash::value_type(PVR2TexturePixelFormat::A8, backend::PixelFormat::A8),
|
|
|
|
_pixel2_formathash::value_type(PVR2TexturePixelFormat::I8, backend::PixelFormat::L8),
|
|
|
|
_pixel2_formathash::value_type(PVR2TexturePixelFormat::AI88, backend::PixelFormat::LA8),
|
|
|
|
|
|
|
|
_pixel2_formathash::value_type(PVR2TexturePixelFormat::PVRTC2BPP_RGBA, backend::PixelFormat::PVRTC2A),
|
|
|
|
_pixel2_formathash::value_type(PVR2TexturePixelFormat::PVRTC4BPP_RGBA, backend::PixelFormat::PVRTC4A),
|
|
|
|
};
|
|
|
|
|
|
|
|
static const int PVR2_MAX_TABLE_ELEMENTS = sizeof(v2_pixel_formathash_value) / sizeof(v2_pixel_formathash_value[0]);
|
|
|
|
static const _pixel2_formathash v2_pixel_formathash(v2_pixel_formathash_value,
|
|
|
|
v2_pixel_formathash_value + PVR2_MAX_TABLE_ELEMENTS);
|
|
|
|
|
|
|
|
// v3
|
|
|
|
typedef const std::map<PVR3TexturePixelFormat, backend::PixelFormat> _pixel3_formathash;
|
|
|
|
static _pixel3_formathash::value_type v3_pixel_formathash_value[] = {
|
|
|
|
_pixel3_formathash::value_type(PVR3TexturePixelFormat::BGRA8888, backend::PixelFormat::BGRA8),
|
|
|
|
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA8888, backend::PixelFormat::RGBA8),
|
|
|
|
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA4444, backend::PixelFormat::RGBA4),
|
|
|
|
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA5551, backend::PixelFormat::RGB5A1),
|
|
|
|
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGB565, backend::PixelFormat::RGB565),
|
|
|
|
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGB888, backend::PixelFormat::RGB8),
|
|
|
|
_pixel3_formathash::value_type(PVR3TexturePixelFormat::A8, backend::PixelFormat::A8),
|
|
|
|
_pixel3_formathash::value_type(PVR3TexturePixelFormat::L8, backend::PixelFormat::L8),
|
|
|
|
_pixel3_formathash::value_type(PVR3TexturePixelFormat::LA88, backend::PixelFormat::LA8),
|
|
|
|
|
|
|
|
_pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC2BPP_RGB, backend::PixelFormat::PVRTC2),
|
|
|
|
_pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC2BPP_RGBA, backend::PixelFormat::PVRTC2A),
|
|
|
|
_pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC4BPP_RGB, backend::PixelFormat::PVRTC4),
|
|
|
|
_pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC4BPP_RGBA, backend::PixelFormat::PVRTC4A),
|
|
|
|
|
|
|
|
_pixel3_formathash::value_type(PVR3TexturePixelFormat::ETC1, backend::PixelFormat::ETC1),
|
|
|
|
};
|
|
|
|
|
|
|
|
static const int PVR3_MAX_TABLE_ELEMENTS = sizeof(v3_pixel_formathash_value) / sizeof(v3_pixel_formathash_value[0]);
|
|
|
|
|
|
|
|
static const _pixel3_formathash v3_pixel_formathash(v3_pixel_formathash_value,
|
|
|
|
v3_pixel_formathash_value + PVR3_MAX_TABLE_ELEMENTS);
|
|
|
|
|
|
|
|
typedef struct _PVRTexHeader
|
|
|
|
{
|
|
|
|
unsigned int headerLength;
|
|
|
|
unsigned int height;
|
|
|
|
unsigned int width;
|
|
|
|
unsigned int numMipmaps;
|
|
|
|
unsigned int flags;
|
|
|
|
unsigned int dataLength;
|
|
|
|
unsigned int bpp;
|
|
|
|
unsigned int bitmaskRed;
|
|
|
|
unsigned int bitmaskGreen;
|
|
|
|
unsigned int bitmaskBlue;
|
|
|
|
unsigned int bitmaskAlpha;
|
|
|
|
unsigned int pvrTag;
|
|
|
|
unsigned int numSurfs;
|
|
|
|
} PVRv2TexHeader;
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
#ifdef _MSC_VER
|
2021-12-25 10:04:45 +08:00
|
|
|
# pragma pack(push, 1)
|
2019-11-23 20:27:39 +08:00
|
|
|
#endif
|
2021-12-25 10:04:45 +08:00
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
uint32_t version;
|
|
|
|
uint32_t flags;
|
|
|
|
uint64_t pixelFormat;
|
|
|
|
uint32_t colorSpace;
|
|
|
|
uint32_t channelType;
|
|
|
|
uint32_t height;
|
|
|
|
uint32_t width;
|
|
|
|
uint32_t depth;
|
|
|
|
uint32_t numberOfSurfaces;
|
|
|
|
uint32_t numberOfFaces;
|
|
|
|
uint32_t numberOfMipmaps;
|
|
|
|
uint32_t metadataLength;
|
2019-11-23 20:27:39 +08:00
|
|
|
#ifdef _MSC_VER
|
2021-12-25 10:04:45 +08:00
|
|
|
} PVRv3TexHeader;
|
|
|
|
# pragma pack(pop)
|
2019-11-23 20:27:39 +08:00
|
|
|
#else
|
2021-12-25 10:04:45 +08:00
|
|
|
} __attribute__((packed)) PVRv3TexHeader;
|
2019-11-23 20:27:39 +08:00
|
|
|
#endif
|
2021-12-25 10:04:45 +08:00
|
|
|
} // namespace
|
|
|
|
// pvr structure end
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
// struct and data for s3tc(dds) struct
|
2019-11-23 20:27:39 +08:00
|
|
|
namespace
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
struct DDColorKey
|
|
|
|
{
|
|
|
|
uint32_t colorSpaceLowValue;
|
|
|
|
uint32_t colorSpaceHighValue;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct DDSCaps
|
|
|
|
{
|
|
|
|
uint32_t caps;
|
|
|
|
uint32_t caps2;
|
|
|
|
uint32_t caps3;
|
|
|
|
uint32_t caps4;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct DDPixelFormat
|
|
|
|
{
|
|
|
|
uint32_t size;
|
|
|
|
uint32_t flags;
|
|
|
|
uint32_t fourCC;
|
|
|
|
uint32_t RGBBitCount;
|
|
|
|
uint32_t RBitMask;
|
|
|
|
uint32_t GBitMask;
|
|
|
|
uint32_t BBitMask;
|
|
|
|
uint32_t ABitMask;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct DDSURFACEDESC2
|
|
|
|
{
|
|
|
|
uint32_t size;
|
|
|
|
uint32_t flags;
|
|
|
|
uint32_t height;
|
|
|
|
uint32_t width;
|
|
|
|
|
|
|
|
union
|
|
|
|
{
|
|
|
|
uint32_t pitch;
|
|
|
|
uint32_t linearSize;
|
|
|
|
} DUMMYUNIONNAMEN1;
|
|
|
|
|
|
|
|
union
|
|
|
|
{
|
|
|
|
uint32_t backBufferCount;
|
|
|
|
uint32_t depth;
|
|
|
|
} DUMMYUNIONNAMEN5;
|
|
|
|
|
|
|
|
union
|
|
|
|
{
|
|
|
|
uint32_t mipMapCount;
|
|
|
|
uint32_t refreshRate;
|
|
|
|
uint32_t srcVBHandle;
|
|
|
|
} DUMMYUNIONNAMEN2;
|
|
|
|
|
|
|
|
uint32_t alphaBitDepth;
|
|
|
|
uint32_t reserved;
|
|
|
|
uint32_t surface;
|
|
|
|
|
|
|
|
union
|
|
|
|
{
|
|
|
|
DDColorKey ddckCKDestOverlay;
|
|
|
|
uint32_t emptyFaceColor;
|
|
|
|
} DUMMYUNIONNAMEN3;
|
|
|
|
|
|
|
|
DDColorKey ddckCKDestBlt;
|
|
|
|
DDColorKey ddckCKSrcOverlay;
|
|
|
|
DDColorKey ddckCKSrcBlt;
|
|
|
|
|
|
|
|
union
|
|
|
|
{
|
|
|
|
DDPixelFormat ddpfPixelFormat;
|
|
|
|
uint32_t FVF;
|
|
|
|
} DUMMYUNIONNAMEN4;
|
|
|
|
|
|
|
|
DDSCaps ddsCaps;
|
|
|
|
uint32_t textureStage;
|
|
|
|
};
|
|
|
|
|
|
|
|
#pragma pack(push, 1)
|
|
|
|
|
|
|
|
struct S3TCTexHeader
|
|
|
|
{
|
|
|
|
char fileCode[4];
|
|
|
|
DDSURFACEDESC2 ddsd;
|
|
|
|
};
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
#pragma pack(pop)
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
} // namespace
|
|
|
|
// s3tc struct end
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
namespace
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
const uint8_t* data;
|
|
|
|
ssize_t size;
|
|
|
|
int offset;
|
|
|
|
} tImageSource;
|
|
|
|
|
2022-07-15 19:17:01 +08:00
|
|
|
#if AX_USE_PNG
|
2021-12-25 10:04:45 +08:00
|
|
|
void pngWriteCallback(png_structp png_ptr, png_bytep data, size_t length)
|
|
|
|
{
|
|
|
|
if (png_ptr == NULL)
|
|
|
|
return;
|
2021-04-22 19:49:43 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
FileStream* fileStream = (FileStream*)png_get_io_ptr(png_ptr);
|
2021-04-22 19:49:43 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
const auto check = fileStream->write(data, length);
|
2021-04-22 19:49:43 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (check != length)
|
|
|
|
png_error(png_ptr, "Write Error");
|
|
|
|
}
|
2021-04-22 19:49:43 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
static void pngReadCallback(png_structp png_ptr, png_bytep data, png_size_t length)
|
|
|
|
{
|
|
|
|
tImageSource* isource = (tImageSource*)png_get_io_ptr(png_ptr);
|
|
|
|
|
|
|
|
if ((int)(isource->offset + length) <= isource->size)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
memcpy(data, isource->data + isource->offset, length);
|
|
|
|
isource->offset += length;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
png_error(png_ptr, "pngReaderCallback failed");
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
2022-07-15 19:17:01 +08:00
|
|
|
#endif // AX_USE_PNG
|
2021-12-25 10:04:45 +08:00
|
|
|
} // namespace
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2020-09-01 11:43:03 +08:00
|
|
|
/*
|
2022-07-09 22:23:34 +08:00
|
|
|
* Notes: PVR file Specification have many pixel formats, cocos2d-x-v2~v4 and axis only support pvrtc and etc1
|
2021-12-25 10:04:45 +08:00
|
|
|
* see: https://cdn.imgtec.com/sdk-documentation/PVR+File+Format.Specification.pdf
|
|
|
|
*/
|
2020-09-01 11:43:03 +08:00
|
|
|
static backend::PixelFormat getDevicePVRPixelFormat(backend::PixelFormat format)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
switch (format)
|
|
|
|
{
|
|
|
|
case backend::PixelFormat::PVRTC4:
|
|
|
|
case backend::PixelFormat::PVRTC4A:
|
|
|
|
case backend::PixelFormat::PVRTC2:
|
|
|
|
case backend::PixelFormat::PVRTC2A:
|
|
|
|
if (Configuration::getInstance()->supportsPVRTC())
|
2019-11-23 20:27:39 +08:00
|
|
|
return format;
|
2021-12-25 10:04:45 +08:00
|
|
|
else
|
|
|
|
return backend::PixelFormat::RGBA8;
|
|
|
|
case backend::PixelFormat::ETC1:
|
|
|
|
if (Configuration::getInstance()->supportsETC1())
|
|
|
|
return format;
|
|
|
|
else if (Configuration::getInstance()->supportsETC2())
|
|
|
|
return backend::PixelFormat::ETC2_RGB;
|
|
|
|
else
|
|
|
|
return backend::PixelFormat::RGBA8;
|
|
|
|
default:
|
|
|
|
return format;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-31 23:09:42 +08:00
|
|
|
namespace
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
bool testFormatForPvr2TCSupport(PVR2TexturePixelFormat /*format*/)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool testFormatForPvr3TCSupport(PVR3TexturePixelFormat format)
|
|
|
|
{
|
|
|
|
switch (format)
|
|
|
|
{
|
|
|
|
case PVR3TexturePixelFormat::DXT1:
|
|
|
|
case PVR3TexturePixelFormat::DXT3:
|
|
|
|
case PVR3TexturePixelFormat::DXT5:
|
|
|
|
return Configuration::getInstance()->supportsS3TC();
|
|
|
|
|
|
|
|
case PVR3TexturePixelFormat::BGRA8888:
|
|
|
|
return Configuration::getInstance()->supportsBGRA8888();
|
|
|
|
|
|
|
|
case PVR3TexturePixelFormat::PVRTC2BPP_RGB:
|
|
|
|
case PVR3TexturePixelFormat::PVRTC2BPP_RGBA:
|
|
|
|
case PVR3TexturePixelFormat::PVRTC4BPP_RGB:
|
|
|
|
case PVR3TexturePixelFormat::PVRTC4BPP_RGBA:
|
|
|
|
case PVR3TexturePixelFormat::ETC1:
|
|
|
|
case PVR3TexturePixelFormat::RGBA8888:
|
|
|
|
case PVR3TexturePixelFormat::RGBA4444:
|
|
|
|
case PVR3TexturePixelFormat::RGBA5551:
|
|
|
|
case PVR3TexturePixelFormat::RGB565:
|
|
|
|
case PVR3TexturePixelFormat::RGB888:
|
|
|
|
case PVR3TexturePixelFormat::A8:
|
|
|
|
case PVR3TexturePixelFormat::L8:
|
|
|
|
case PVR3TexturePixelFormat::LA88:
|
2020-08-31 23:09:42 +08:00
|
|
|
return true;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
default:
|
|
|
|
return false;
|
2020-08-31 23:09:42 +08:00
|
|
|
}
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
} // namespace
|
2020-08-31 23:09:42 +08:00
|
|
|
|
|
|
|
namespace
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
static uint32_t makeFourCC(char ch0, char ch1, char ch2, char ch3)
|
|
|
|
{
|
|
|
|
const uint32_t fourCC = ((uint32_t)(char)(ch0) | ((uint32_t)(char)(ch1) << 8) | ((uint32_t)(char)(ch2) << 16) |
|
|
|
|
((uint32_t)(char)(ch3) << 24));
|
|
|
|
return fourCC;
|
2020-08-31 23:09:42 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
} // namespace
|
2020-08-31 23:09:42 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
// Implement Image
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
bool Image::PNG_PREMULTIPLIED_ALPHA_ENABLED = true;
|
2021-12-25 10:04:45 +08:00
|
|
|
uint32_t Image::COMPRESSED_IMAGE_PMA_FLAGS = Image::CompressedImagePMAFlag::DUAL_SAMPLER;
|
2020-11-16 12:21:27 +08:00
|
|
|
|
|
|
|
void Image::setCompressedImagesHavePMA(uint32_t targets, bool havePMA)
|
|
|
|
{
|
|
|
|
if (havePMA)
|
|
|
|
COMPRESSED_IMAGE_PMA_FLAGS |= targets;
|
|
|
|
else
|
|
|
|
COMPRESSED_IMAGE_PMA_FLAGS &= ~targets;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Image::isCompressedImageHavePMA(uint32_t target)
|
|
|
|
{
|
|
|
|
return target & COMPRESSED_IMAGE_PMA_FLAGS;
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
Image::Image()
|
2021-12-25 10:04:45 +08:00
|
|
|
: _data(nullptr)
|
|
|
|
, _dataLen(0)
|
|
|
|
, _offset(0)
|
|
|
|
, _width(0)
|
|
|
|
, _height(0)
|
|
|
|
, _unpack(false)
|
|
|
|
, _fileType(Format::UNKNOWN)
|
|
|
|
, _pixelFormat(backend::PixelFormat::NONE)
|
|
|
|
, _numberOfMipmaps(0)
|
|
|
|
, _hasPremultipliedAlpha(false)
|
|
|
|
{}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
Image::~Image()
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (!_unpack)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_SAFE_FREE(_data);
|
2020-08-31 21:04:47 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
for (int i = 0; i < _numberOfMipmaps; ++i)
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_SAFE_FREE(_mipmaps[i].address);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool Image::initWithImageFile(std::string_view path)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
bool ret = false;
|
2019-11-23 20:27:39 +08:00
|
|
|
_filePath = FileUtils::getInstance()->fullPathForFilename(path);
|
|
|
|
|
|
|
|
Data data = FileUtils::getInstance()->getDataFromFile(_filePath);
|
|
|
|
|
|
|
|
if (!data.isNull())
|
|
|
|
{
|
|
|
|
ssize_t n = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
auto buf = data.takeBuffer(&n);
|
|
|
|
ret = initWithImageData(buf, n, true);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool Image::initWithImageFileThreadSafe(std::string_view fullpath)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
bool ret = false;
|
2019-11-23 20:27:39 +08:00
|
|
|
_filePath = fullpath;
|
|
|
|
|
2020-08-18 14:29:09 +08:00
|
|
|
Data data = FileUtils::getInstance()->getDataFromFile(_filePath);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (!data.isNull())
|
|
|
|
{
|
|
|
|
ssize_t n = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
auto buf = data.takeBuffer(&n);
|
|
|
|
ret = initWithImageData(buf, n, true);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::initWithImageData(const uint8_t* data, ssize_t dataLen)
|
2021-05-24 13:26:56 +08:00
|
|
|
{
|
|
|
|
return initWithImageData(const_cast<uint8_t*>(data), dataLen, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Image::initWithImageData(uint8_t* data, ssize_t dataLen, bool ownData)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
bool ret = false;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
do
|
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_BREAK_IF(!data || dataLen == 0);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2020-09-01 14:57:18 +08:00
|
|
|
uint8_t* unpackedData = nullptr;
|
2021-12-25 10:04:45 +08:00
|
|
|
ssize_t unpackedLen = 0;
|
|
|
|
|
|
|
|
// detect and unzip the compress file
|
2019-11-23 20:27:39 +08:00
|
|
|
if (ZipUtils::isCCZBuffer(data, dataLen))
|
|
|
|
{
|
|
|
|
unpackedLen = ZipUtils::inflateCCZBuffer(data, dataLen, &unpackedData);
|
|
|
|
}
|
|
|
|
else if (ZipUtils::isGZipBuffer(data, dataLen))
|
|
|
|
{
|
2020-09-01 14:57:18 +08:00
|
|
|
unpackedLen = ZipUtils::inflateMemory(const_cast<uint8_t*>(data), dataLen, &unpackedData);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-09-01 14:57:18 +08:00
|
|
|
unpackedData = const_cast<uint8_t*>(data);
|
2021-12-25 10:04:45 +08:00
|
|
|
unpackedLen = dataLen;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (unpackedData != data)
|
|
|
|
{ // free old data and own the unpackedData
|
|
|
|
if (ownData)
|
|
|
|
free((void*)data);
|
2020-08-31 21:04:47 +08:00
|
|
|
ownData = true;
|
|
|
|
}
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
_fileType = detectFormat(unpackedData, unpackedLen);
|
|
|
|
|
|
|
|
switch (_fileType)
|
|
|
|
{
|
|
|
|
case Format::PNG:
|
|
|
|
ret = initWithPngData(unpackedData, unpackedLen);
|
|
|
|
break;
|
|
|
|
case Format::JPG:
|
|
|
|
ret = initWithJpgData(unpackedData, unpackedLen);
|
|
|
|
break;
|
|
|
|
case Format::WEBP:
|
|
|
|
ret = initWithWebpData(unpackedData, unpackedLen);
|
|
|
|
break;
|
|
|
|
case Format::PVR:
|
2020-08-31 23:09:42 +08:00
|
|
|
ret = initWithPVRData(unpackedData, unpackedLen, ownData);
|
2019-11-23 20:27:39 +08:00
|
|
|
break;
|
2020-09-01 11:43:03 +08:00
|
|
|
case Format::ETC1:
|
2020-08-31 23:09:42 +08:00
|
|
|
ret = initWithETCData(unpackedData, unpackedLen, ownData);
|
2020-08-31 21:04:47 +08:00
|
|
|
break;
|
|
|
|
case Format::ETC2:
|
2020-08-31 23:09:42 +08:00
|
|
|
ret = initWithETC2Data(unpackedData, unpackedLen, ownData);
|
2019-11-23 20:27:39 +08:00
|
|
|
break;
|
|
|
|
case Format::S3TC:
|
2020-08-31 23:09:42 +08:00
|
|
|
ret = initWithS3TCData(unpackedData, unpackedLen, ownData);
|
2019-11-23 20:27:39 +08:00
|
|
|
break;
|
|
|
|
case Format::ATITC:
|
2020-08-31 23:09:42 +08:00
|
|
|
ret = initWithATITCData(unpackedData, unpackedLen, ownData);
|
2019-11-23 20:27:39 +08:00
|
|
|
break;
|
2020-02-12 20:24:29 +08:00
|
|
|
case Format::ASTC:
|
2020-08-31 23:09:42 +08:00
|
|
|
ret = initWithASTCData(unpackedData, unpackedLen, ownData);
|
2020-02-12 20:24:29 +08:00
|
|
|
break;
|
2019-11-25 02:28:38 +08:00
|
|
|
case Format::BMP:
|
|
|
|
ret = initWithBmpData(unpackedData, unpackedLen);
|
|
|
|
break;
|
2019-11-23 20:27:39 +08:00
|
|
|
default:
|
2021-12-25 10:04:45 +08:00
|
|
|
{
|
|
|
|
// load and detect image format
|
|
|
|
tImageTGA* tgaData = tgaLoadBuffer(unpackedData, unpackedLen);
|
|
|
|
|
|
|
|
if (tgaData != nullptr && tgaData->status == TGA_OK)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
ret = initWithTGAData(tgaData);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
CCLOG("cocos2d: unsupported image format!");
|
|
|
|
}
|
|
|
|
|
|
|
|
free(tgaData);
|
|
|
|
break;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (_data != unpackedData && ownData)
|
|
|
|
free(unpackedData);
|
2020-08-31 21:04:47 +08:00
|
|
|
// else, the hardware texture decoder used, the compressed data was stored directly
|
2019-11-23 20:27:39 +08:00
|
|
|
} while (0);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::initWithRawData(const uint8_t* data,
|
|
|
|
ssize_t /*dataLen*/,
|
|
|
|
int width,
|
|
|
|
int height,
|
|
|
|
int /*bitsPerComponent*/,
|
|
|
|
bool preMulti)
|
2020-09-01 11:43:03 +08:00
|
|
|
{
|
|
|
|
bool ret = false;
|
|
|
|
do
|
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_BREAK_IF(0 == width || 0 == height);
|
2020-09-01 11:43:03 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
_height = height;
|
|
|
|
_width = width;
|
2020-09-01 11:43:03 +08:00
|
|
|
_hasPremultipliedAlpha = preMulti;
|
2021-12-25 10:04:45 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::RGBA8;
|
2020-09-01 11:43:03 +08:00
|
|
|
|
|
|
|
// only RGBA8888 supported
|
|
|
|
int bytesPerComponent = 4;
|
2021-12-25 10:04:45 +08:00
|
|
|
_dataLen = height * width * bytesPerComponent;
|
|
|
|
_data = static_cast<uint8_t*>(malloc(_dataLen));
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_BREAK_IF(!_data);
|
2020-09-01 11:43:03 +08:00
|
|
|
memcpy(_data, data, _dataLen);
|
|
|
|
|
|
|
|
ret = true;
|
|
|
|
} while (0);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::isPng(const uint8_t* data, ssize_t dataLen)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (dataLen <= 8)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-09-01 14:57:18 +08:00
|
|
|
static const uint8_t PNG_SIGNATURE[] = {0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a};
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
return memcmp(PNG_SIGNATURE, data, sizeof(PNG_SIGNATURE)) == 0;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::isBmp(const uint8_t* data, ssize_t dataLen)
|
2019-11-25 02:28:38 +08:00
|
|
|
{
|
|
|
|
return dataLen > 54 && data[0] == 'B' && data[1] == 'M';
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::isEtc1(const uint8_t* data, ssize_t /*dataLen*/)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2020-08-31 21:04:47 +08:00
|
|
|
return !!etc1_pkm_is_valid((etc1_byte*)data);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2020-09-01 14:57:18 +08:00
|
|
|
bool Image::isEtc2(const uint8_t* data, ssize_t dataLen)
|
2020-08-31 21:04:47 +08:00
|
|
|
{
|
|
|
|
return !!etc2_pkm_is_valid((etc2_byte*)data);
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::isS3TC(const uint8_t* data, ssize_t /*dataLen*/)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
S3TCTexHeader* header = (S3TCTexHeader*)data;
|
|
|
|
|
2020-08-31 21:04:47 +08:00
|
|
|
return (strncmp(header->fileCode, "DDS", 3) == 0);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2020-09-01 14:57:18 +08:00
|
|
|
bool Image::isASTC(const uint8_t* data, ssize_t /*dataLen*/)
|
2020-02-12 20:24:29 +08:00
|
|
|
{
|
2021-06-01 23:43:28 +08:00
|
|
|
astc_header* hdr = (astc_header*)data;
|
2020-02-12 20:24:29 +08:00
|
|
|
|
2021-06-01 23:43:28 +08:00
|
|
|
uint32_t magicval = astc_unpack_bytes(hdr->magic[0], hdr->magic[1], hdr->magic[2], hdr->magic[3]);
|
2020-02-12 20:24:29 +08:00
|
|
|
|
2021-06-01 23:43:28 +08:00
|
|
|
return (magicval == ASTC_MAGIC_ID);
|
2020-02-12 20:24:29 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::isJpg(const uint8_t* data, ssize_t dataLen)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (dataLen <= 4)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-09-01 14:57:18 +08:00
|
|
|
static const uint8_t JPG_SOI[] = {0xFF, 0xD8};
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
return memcmp(data, JPG_SOI, 2) == 0;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::isWebp(const uint8_t* data, ssize_t dataLen)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (dataLen <= 12)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char* WEBP_RIFF = "RIFF";
|
|
|
|
static const char* WEBP_WEBP = "WEBP";
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
return memcmp(data, WEBP_RIFF, 4) == 0 && memcmp(static_cast<const uint8_t*>(data) + 8, WEBP_WEBP, 4) == 0;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::isPvr(const uint8_t* data, ssize_t dataLen)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (static_cast<size_t>(dataLen) < sizeof(PVRv2TexHeader) || static_cast<size_t>(dataLen) < sizeof(PVRv3TexHeader))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
const PVRv2TexHeader* headerv2 = static_cast<const PVRv2TexHeader*>(static_cast<const void*>(data));
|
|
|
|
const PVRv3TexHeader* headerv3 = static_cast<const PVRv3TexHeader*>(static_cast<const void*>(data));
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
return memcmp(&headerv2->pvrTag, gPVRTexIdentifier, strlen(gPVRTexIdentifier)) == 0 ||
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_SWAP_INT32_BIG_TO_HOST(headerv3->version) == 0x50565203;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
Image::Format Image::detectFormat(const uint8_t* data, ssize_t dataLen)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (isPng(data, dataLen))
|
|
|
|
{
|
|
|
|
return Format::PNG;
|
|
|
|
}
|
|
|
|
else if (isJpg(data, dataLen))
|
|
|
|
{
|
|
|
|
return Format::JPG;
|
|
|
|
}
|
2019-11-25 02:28:38 +08:00
|
|
|
else if (isBmp(data, dataLen))
|
|
|
|
{
|
|
|
|
return Format::BMP;
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
else if (isWebp(data, dataLen))
|
|
|
|
{
|
|
|
|
return Format::WEBP;
|
|
|
|
}
|
|
|
|
else if (isPvr(data, dataLen))
|
|
|
|
{
|
|
|
|
return Format::PVR;
|
|
|
|
}
|
2020-09-01 11:43:03 +08:00
|
|
|
else if (isEtc1(data, dataLen))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2020-09-01 11:43:03 +08:00
|
|
|
return Format::ETC1;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2020-08-31 21:04:47 +08:00
|
|
|
else if (isEtc2(data, dataLen))
|
|
|
|
{
|
|
|
|
return Format::ETC2;
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
else if (isS3TC(data, dataLen))
|
|
|
|
{
|
|
|
|
return Format::S3TC;
|
|
|
|
}
|
2020-02-12 20:24:29 +08:00
|
|
|
else if (isASTC(data, dataLen))
|
|
|
|
{
|
|
|
|
return Format::ASTC;
|
|
|
|
}
|
2022-04-25 19:11:58 +08:00
|
|
|
else if (dataLen >= KTX_V1_HEADER_SIZE)
|
|
|
|
{ // Check whether ktxspec v1.1 file format
|
|
|
|
auto header = (KTXv1Header*)data;
|
|
|
|
if (memcmp(&header->identifier[1], KTX_V1_MAGIC, sizeof(KTX_V1_MAGIC) - 1) == 0)
|
|
|
|
{
|
|
|
|
switch (header->glInternalFormat)
|
|
|
|
{
|
|
|
|
case KTXv1Header::InternalFormat::ATC_RGB_AMD:
|
|
|
|
case KTXv1Header::InternalFormat::ATC_RGBA_INTERPOLATED_ALPHA_AMD:
|
|
|
|
case KTXv1Header::InternalFormat::ATC_RGBA_EXPLICIT_ALPHA_AMD:
|
|
|
|
return Format::ATITC;
|
|
|
|
case KTXv1Header::InternalFormat::ETC2_RGB8:
|
|
|
|
case KTXv1Header::InternalFormat::ETC2_RGBA8:
|
|
|
|
return Format::ETC2;
|
|
|
|
case KTXv1Header::InternalFormat::ETC1_RGB8:
|
|
|
|
return Format::ETC1;
|
|
|
|
default:;
|
|
|
|
}
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2022-04-25 19:11:58 +08:00
|
|
|
|
|
|
|
return Format::UNKNOWN;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int Image::getBitPerPixel()
|
|
|
|
{
|
2020-11-02 16:47:07 +08:00
|
|
|
return backend::PixelFormatUtils::getFormatDescriptor(_pixelFormat).bpp;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Image::hasAlpha()
|
|
|
|
{
|
2020-09-25 11:07:56 +08:00
|
|
|
return backend::PixelFormatUtils::getFormatDescriptor(_pixelFormat).alpha;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Image::isCompressed()
|
|
|
|
{
|
2020-09-25 11:07:56 +08:00
|
|
|
return backend::PixelFormatUtils::isCompressed(_pixelFormat);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
namespace
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* ERROR HANDLING:
|
|
|
|
*
|
|
|
|
* The JPEG library's standard error handler (jerror.c) is divided into
|
|
|
|
* several "methods" which you can override individually. This lets you
|
|
|
|
* adjust the behavior without duplicating a lot of code, which you might
|
|
|
|
* have to update with each future release.
|
|
|
|
*
|
|
|
|
* We override the "error_exit" method so that control is returned to the
|
|
|
|
* library's caller when a fatal error occurs, rather than calling exit()
|
|
|
|
* as the standard error_exit method does.
|
|
|
|
*
|
|
|
|
* We use C's setjmp/longjmp facility to return control. This means that the
|
|
|
|
* routine which calls the JPEG library must first execute a setjmp() call to
|
|
|
|
* establish the return point. We want the replacement error_exit to do a
|
|
|
|
* longjmp(). But we need to make the setjmp buffer accessible to the
|
|
|
|
* error_exit routine. To do this, we make a private extension of the
|
|
|
|
* standard JPEG error handler object. (If we were using C++, we'd say we
|
|
|
|
* were making a subclass of the regular error handler.)
|
|
|
|
*
|
|
|
|
* Here's the extended error handler struct:
|
|
|
|
*/
|
2022-07-15 19:17:01 +08:00
|
|
|
#if AX_USE_JPEG
|
2021-12-25 10:04:45 +08:00
|
|
|
struct MyErrorMgr
|
|
|
|
{
|
|
|
|
struct jpeg_error_mgr pub; /* "public" fields */
|
|
|
|
jmp_buf setjmp_buffer; /* for return to caller */
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct MyErrorMgr* MyErrorPtr;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Here's the routine that will replace the standard error_exit method:
|
|
|
|
*/
|
|
|
|
|
|
|
|
METHODDEF(void)
|
|
|
|
myErrorExit(j_common_ptr cinfo)
|
|
|
|
{
|
|
|
|
/* cinfo->err really points to a MyErrorMgr struct, so coerce pointer */
|
|
|
|
MyErrorPtr myerr = (MyErrorPtr)cinfo->err;
|
|
|
|
|
|
|
|
/* Always display the message. */
|
|
|
|
/* We could postpone this until after returning, if we chose. */
|
|
|
|
/* internal message function can't show error message in some platforms, so we rewrite it here.
|
|
|
|
* edit it if has version conflict.
|
2019-11-23 20:27:39 +08:00
|
|
|
*/
|
2021-12-25 10:04:45 +08:00
|
|
|
//(*cinfo->err->output_message) (cinfo);
|
|
|
|
char buffer[JMSG_LENGTH_MAX];
|
|
|
|
(*cinfo->err->format_message)(cinfo, buffer);
|
|
|
|
CCLOG("jpeg error: %s", buffer);
|
|
|
|
|
|
|
|
/* Return control to the setjmp point */
|
|
|
|
longjmp(myerr->setjmp_buffer, 1);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2022-07-15 19:17:01 +08:00
|
|
|
#endif // AX_USE_JPEG
|
2021-12-25 10:04:45 +08:00
|
|
|
} // namespace
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::initWithJpgData(uint8_t* data, ssize_t dataLen)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
#if AX_USE_JPEG
|
2019-11-23 20:27:39 +08:00
|
|
|
/* these are standard libjpeg structures for reading(decompression) */
|
|
|
|
struct jpeg_decompress_struct cinfo;
|
|
|
|
/* We use our private extension JPEG error handler.
|
|
|
|
* Note that this struct must live as long as the main JPEG parameter
|
|
|
|
* struct, to avoid dangling-pointer problems.
|
|
|
|
*/
|
|
|
|
struct MyErrorMgr jerr;
|
|
|
|
/* libjpeg data structure for storing one row, that is, scanline of an image */
|
|
|
|
JSAMPROW row_pointer[1] = {0};
|
2021-12-25 10:04:45 +08:00
|
|
|
uint32_t location = 0;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
bool ret = false;
|
2021-12-25 10:04:45 +08:00
|
|
|
do
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
/* We set up the normal JPEG error routines, then override error_exit. */
|
2021-12-25 10:04:45 +08:00
|
|
|
cinfo.err = jpeg_std_error(&jerr.pub);
|
2019-11-23 20:27:39 +08:00
|
|
|
jerr.pub.error_exit = myErrorExit;
|
|
|
|
/* Establish the setjmp return context for MyErrorExit to use. */
|
|
|
|
if (setjmp(jerr.setjmp_buffer))
|
|
|
|
{
|
|
|
|
/* If we get here, the JPEG code has signaled an error.
|
|
|
|
* We need to clean up the JPEG object, close the input file, and return.
|
|
|
|
*/
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* setup decompression process and source, then read JPEG header */
|
2021-12-25 10:04:45 +08:00
|
|
|
jpeg_create_decompress(&cinfo);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2022-07-15 19:17:01 +08:00
|
|
|
# ifndef AX_TARGET_QT5
|
2020-09-01 14:57:18 +08:00
|
|
|
jpeg_mem_src(&cinfo, const_cast<uint8_t*>(data), dataLen);
|
2022-07-15 19:17:01 +08:00
|
|
|
# endif /* AX_TARGET_QT5 */
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
/* reading the image header which contains image information */
|
2021-12-25 10:04:45 +08:00
|
|
|
# if (JPEG_LIB_VERSION >= 90)
|
2019-11-23 20:27:39 +08:00
|
|
|
// libjpeg 0.9 adds stricter types.
|
|
|
|
jpeg_read_header(&cinfo, TRUE);
|
2021-12-25 10:04:45 +08:00
|
|
|
# else
|
2019-11-23 20:27:39 +08:00
|
|
|
jpeg_read_header(&cinfo, TRUE);
|
2021-12-25 10:04:45 +08:00
|
|
|
# endif //(JPEG_LIB_VERSION >= 90)
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// we only support RGB or grayscale
|
|
|
|
if (cinfo.jpeg_color_space == JCS_GRAYSCALE)
|
|
|
|
{
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::L8;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
cinfo.out_color_space = JCS_RGB;
|
2021-12-25 10:04:45 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::RGB8;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Start decompression jpeg here */
|
2021-12-25 10:04:45 +08:00
|
|
|
jpeg_start_decompress(&cinfo);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
/* init image info */
|
|
|
|
_width = cinfo.output_width;
|
|
|
|
_height = cinfo.output_height;
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
_dataLen = cinfo.output_width * cinfo.output_height * cinfo.output_components;
|
|
|
|
_data = static_cast<uint8_t*>(malloc(_dataLen));
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_BREAK_IF(!_data);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
/* now actually read the jpeg into the raw buffer */
|
|
|
|
/* read one scan line at a time */
|
|
|
|
while (cinfo.output_scanline < cinfo.output_height)
|
|
|
|
{
|
|
|
|
row_pointer[0] = _data + location;
|
2021-12-25 10:04:45 +08:00
|
|
|
location += cinfo.output_width * cinfo.output_components;
|
2019-11-23 20:27:39 +08:00
|
|
|
jpeg_read_scanlines(&cinfo, row_pointer, 1);
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
/* When read image file with broken data, jpeg_finish_decompress() may cause error.
|
|
|
|
* Besides, jpeg_destroy_decompress() shall deallocate and release all memory associated
|
|
|
|
* with the decompression object.
|
|
|
|
* So it doesn't need to call jpeg_finish_decompress().
|
|
|
|
*/
|
|
|
|
// jpeg_finish_decompress( &cinfo );
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
|
|
|
/* wrap up decompression, destroy objects, free pointers and close open files */
|
2019-11-23 20:27:39 +08:00
|
|
|
ret = true;
|
|
|
|
} while (0);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
#else
|
|
|
|
CCLOG("jpeg is not enabled, please enable it in ccConfig.h");
|
|
|
|
return false;
|
2022-07-15 19:17:01 +08:00
|
|
|
#endif // AX_USE_JPEG
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::initWithPngData(uint8_t* data, ssize_t dataLen)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
#if AX_USE_PNG
|
2019-11-23 20:27:39 +08:00
|
|
|
// length of bytes to check if it is a valid png file
|
2021-12-25 10:04:45 +08:00
|
|
|
# define PNGSIGSIZE 8
|
|
|
|
bool ret = false;
|
|
|
|
png_byte header[PNGSIGSIZE] = {0};
|
|
|
|
png_structp png_ptr = 0;
|
|
|
|
png_infop info_ptr = 0;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
do
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
// png header len is 8 bytes
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_BREAK_IF(dataLen < PNGSIGSIZE);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// check the data is png or not
|
|
|
|
memcpy(header, data, PNGSIGSIZE);
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_BREAK_IF(png_sig_cmp(header, 0, PNGSIGSIZE));
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// init png_struct
|
|
|
|
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_BREAK_IF(!png_ptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// init png_info
|
|
|
|
info_ptr = png_create_info_struct(png_ptr);
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_BREAK_IF(!info_ptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_BREAK_IF(setjmp(png_jmpbuf(png_ptr)));
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// set the read call back function
|
|
|
|
tImageSource imageSource;
|
2021-12-25 10:04:45 +08:00
|
|
|
imageSource.data = (uint8_t*)data;
|
|
|
|
imageSource.size = dataLen;
|
|
|
|
imageSource.offset = 0;
|
2019-11-23 20:27:39 +08:00
|
|
|
png_set_read_fn(png_ptr, &imageSource, pngReadCallback);
|
|
|
|
|
|
|
|
// read png header info
|
|
|
|
|
|
|
|
// read png file info
|
|
|
|
png_read_info(png_ptr, info_ptr);
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
_width = png_get_image_width(png_ptr, info_ptr);
|
|
|
|
_height = png_get_image_height(png_ptr, info_ptr);
|
|
|
|
png_byte bit_depth = png_get_bit_depth(png_ptr, info_ptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
png_uint_32 color_type = png_get_color_type(png_ptr, info_ptr);
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
// CCLOG("color type %u", color_type);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// force palette images to be expanded to 24-bit RGB
|
|
|
|
// it may include alpha channel
|
|
|
|
if (color_type == PNG_COLOR_TYPE_PALETTE)
|
|
|
|
{
|
|
|
|
png_set_palette_to_rgb(png_ptr);
|
|
|
|
}
|
|
|
|
// low-bit-depth grayscale images are to be expanded to 8 bits
|
|
|
|
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
|
|
|
|
{
|
|
|
|
bit_depth = 8;
|
|
|
|
png_set_expand_gray_1_2_4_to_8(png_ptr);
|
|
|
|
}
|
|
|
|
// expand any tRNS chunk data into a full alpha channel
|
|
|
|
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
|
|
|
|
{
|
|
|
|
png_set_tRNS_to_alpha(png_ptr);
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
// reduce images with 16-bit samples to 8 bits
|
|
|
|
if (bit_depth == 16)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
png_set_strip_16(png_ptr);
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// Expanded earlier for grayscale, now take care of palette and rgb
|
|
|
|
if (bit_depth < 8)
|
|
|
|
{
|
|
|
|
png_set_packing(png_ptr);
|
|
|
|
}
|
|
|
|
// update info
|
|
|
|
png_read_update_info(png_ptr, info_ptr);
|
|
|
|
color_type = png_get_color_type(png_ptr, info_ptr);
|
|
|
|
|
|
|
|
switch (color_type)
|
|
|
|
{
|
|
|
|
case PNG_COLOR_TYPE_GRAY:
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::L8;
|
2019-11-23 20:27:39 +08:00
|
|
|
break;
|
|
|
|
case PNG_COLOR_TYPE_GRAY_ALPHA:
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::LA8;
|
2019-11-23 20:27:39 +08:00
|
|
|
break;
|
|
|
|
case PNG_COLOR_TYPE_RGB:
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::RGB8;
|
2019-11-23 20:27:39 +08:00
|
|
|
break;
|
|
|
|
case PNG_COLOR_TYPE_RGB_ALPHA:
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::RGBA8;
|
2019-11-23 20:27:39 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// read png data
|
|
|
|
png_size_t rowbytes;
|
2021-12-25 10:04:45 +08:00
|
|
|
png_bytep* row_pointers = (png_bytep*)malloc(sizeof(png_bytep) * _height);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
rowbytes = png_get_rowbytes(png_ptr, info_ptr);
|
|
|
|
|
|
|
|
_dataLen = rowbytes * _height;
|
2021-12-25 10:04:45 +08:00
|
|
|
_data = static_cast<uint8_t*>(malloc(_dataLen));
|
2019-11-23 20:27:39 +08:00
|
|
|
if (!_data)
|
|
|
|
{
|
|
|
|
if (row_pointers != nullptr)
|
|
|
|
{
|
|
|
|
free(row_pointers);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (unsigned short i = 0; i < _height; ++i)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
row_pointers[i] = _data + i * rowbytes;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
png_read_image(png_ptr, row_pointers);
|
|
|
|
|
|
|
|
png_read_end(png_ptr, nullptr);
|
|
|
|
|
|
|
|
// premultiplied alpha for RGBA8888
|
|
|
|
if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
|
|
|
|
{
|
|
|
|
if (PNG_PREMULTIPLIED_ALPHA_ENABLED)
|
|
|
|
{
|
|
|
|
premultiplyAlpha();
|
|
|
|
}
|
|
|
|
else
|
2021-12-25 10:04:45 +08:00
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
// if PNG_PREMULTIPLIED_ALPHA_ENABLED == false && AX_ENABLE_PREMULTIPLIED_ALPHA != 0,
|
2020-11-16 12:21:27 +08:00
|
|
|
// you must do PMA at shader, such as modify positionTextureColor.frag
|
2022-07-15 19:17:01 +08:00
|
|
|
_hasPremultipliedAlpha = !!AX_ENABLE_PREMULTIPLIED_ALPHA;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (row_pointers != nullptr)
|
|
|
|
{
|
|
|
|
free(row_pointers);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = true;
|
|
|
|
} while (0);
|
|
|
|
|
|
|
|
if (png_ptr)
|
|
|
|
{
|
|
|
|
png_destroy_read_struct(&png_ptr, (info_ptr) ? &info_ptr : 0, 0);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
#else
|
|
|
|
CCLOG("png is not enabled, please enable it in ccConfig.h");
|
|
|
|
return false;
|
2022-07-15 19:17:01 +08:00
|
|
|
#endif // AX_USE_PNG
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2020-09-01 14:57:18 +08:00
|
|
|
bool Image::initWithBmpData(uint8_t* data, ssize_t dataLen)
|
2019-11-25 02:28:38 +08:00
|
|
|
{
|
2020-09-01 12:06:21 +08:00
|
|
|
const int nrChannels = 4;
|
2021-12-25 10:04:45 +08:00
|
|
|
_data = stbi_load_from_memory(data, dataLen, &_width, &_height, nullptr, nrChannels);
|
|
|
|
if (_data)
|
|
|
|
{
|
|
|
|
_dataLen = _width * _height * nrChannels;
|
|
|
|
_fileType = Format::BMP;
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::RGBA8;
|
2020-09-01 12:06:21 +08:00
|
|
|
return true;
|
2019-11-25 02:28:38 +08:00
|
|
|
}
|
2020-09-01 12:06:21 +08:00
|
|
|
return false;
|
2019-11-25 02:28:38 +08:00
|
|
|
}
|
|
|
|
|
2020-09-01 14:57:18 +08:00
|
|
|
bool Image::initWithWebpData(uint8_t* data, ssize_t dataLen)
|
2020-09-01 11:43:03 +08:00
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
#if AX_USE_WEBP
|
2020-09-01 11:43:03 +08:00
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
WebPDecoderConfig config;
|
2021-12-25 10:04:45 +08:00
|
|
|
if (WebPInitDecoderConfig(&config) == 0)
|
|
|
|
break;
|
|
|
|
if (WebPGetFeatures(static_cast<const uint8_t*>(data), dataLen, &config.input) != VP8_STATUS_OK)
|
|
|
|
break;
|
|
|
|
if (config.input.width == 0 || config.input.height == 0)
|
|
|
|
break;
|
2020-09-01 11:43:03 +08:00
|
|
|
|
|
|
|
config.output.colorspace = config.input.has_alpha ? MODE_rgbA : MODE_RGB;
|
2021-12-25 10:04:45 +08:00
|
|
|
_pixelFormat = config.input.has_alpha ? backend::PixelFormat::RGBA8 : backend::PixelFormat::RGB8;
|
|
|
|
_width = config.input.width;
|
|
|
|
_height = config.input.height;
|
2020-09-01 11:43:03 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
// we ask webp to give data with premultiplied alpha
|
2020-09-01 11:43:03 +08:00
|
|
|
_hasPremultipliedAlpha = (config.input.has_alpha != 0);
|
|
|
|
|
|
|
|
_dataLen = _width * _height * (config.input.has_alpha ? 4 : 3);
|
2021-12-25 10:04:45 +08:00
|
|
|
_data = static_cast<uint8_t*>(malloc(_dataLen));
|
2020-09-01 11:43:03 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
config.output.u.RGBA.rgba = static_cast<uint8_t*>(_data);
|
|
|
|
config.output.u.RGBA.stride = _width * (config.input.has_alpha ? 4 : 3);
|
|
|
|
config.output.u.RGBA.size = _dataLen;
|
2020-09-01 11:43:03 +08:00
|
|
|
config.output.is_external_memory = 1;
|
|
|
|
|
|
|
|
if (WebPDecode(static_cast<const uint8_t*>(data), dataLen, &config) != VP8_STATUS_OK)
|
|
|
|
{
|
|
|
|
free(_data);
|
|
|
|
_data = nullptr;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = true;
|
|
|
|
} while (0);
|
|
|
|
return ret;
|
2021-12-25 10:04:45 +08:00
|
|
|
#else
|
2020-09-01 11:43:03 +08:00
|
|
|
CCLOG("webp is not enabled, please enable it in ccConfig.h");
|
|
|
|
return false;
|
2022-07-15 19:17:01 +08:00
|
|
|
#endif // AX_USE_WEBP
|
2020-09-01 11:43:03 +08:00
|
|
|
}
|
|
|
|
|
2020-08-31 23:09:42 +08:00
|
|
|
bool Image::initWithTGAData(tImageTGA* tgaData)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2020-08-31 23:09:42 +08:00
|
|
|
bool ret = false;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2020-08-31 23:09:42 +08:00
|
|
|
do
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_BREAK_IF(tgaData == nullptr);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2020-08-31 23:09:42 +08:00
|
|
|
// tgaLoadBuffer only support type 2, 3, 10
|
|
|
|
if (2 == tgaData->type || 10 == tgaData->type)
|
|
|
|
{
|
|
|
|
// true color
|
|
|
|
// unsupported RGB555
|
|
|
|
if (tgaData->pixelDepth == 16)
|
|
|
|
{
|
|
|
|
_pixelFormat = backend::PixelFormat::RGB5A1;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else if (tgaData->pixelDepth == 24)
|
2020-08-31 23:09:42 +08:00
|
|
|
{
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::RGB8;
|
2020-08-31 23:09:42 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else if (tgaData->pixelDepth == 32)
|
2020-08-31 23:09:42 +08:00
|
|
|
{
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::RGBA8;
|
2020-08-31 23:09:42 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
CCLOG("Image WARNING: unsupported true color tga data pixel format. FILE: %s", _filePath.c_str());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else if (3 == tgaData->type)
|
2020-08-31 23:09:42 +08:00
|
|
|
{
|
|
|
|
// gray
|
|
|
|
if (8 == tgaData->pixelDepth)
|
|
|
|
{
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::L8;
|
2020-08-31 23:09:42 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// actually this won't happen, if it happens, maybe the image file is not a tga
|
|
|
|
CCLOG("Image WARNING: unsupported gray tga data pixel format. FILE: %s", _filePath.c_str());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
_width = tgaData->width;
|
|
|
|
_height = tgaData->height;
|
|
|
|
_data = tgaData->imageData;
|
|
|
|
_dataLen = _width * _height * tgaData->pixelDepth / 8;
|
2020-08-31 23:09:42 +08:00
|
|
|
_fileType = Format::TGA;
|
|
|
|
|
|
|
|
ret = true;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
} while (false);
|
|
|
|
|
2020-08-31 23:09:42 +08:00
|
|
|
if (ret)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2020-08-31 23:09:42 +08:00
|
|
|
if (FileUtils::getInstance()->getFileExtension(_filePath) != ".tga")
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
CCLOG("Image WARNING: the image file suffix is not tga, but parsed as a tga image file. FILE: %s",
|
|
|
|
_filePath.c_str());
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
2020-08-31 23:09:42 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (tgaData && tgaData->imageData != nullptr)
|
|
|
|
{
|
|
|
|
free(tgaData->imageData);
|
|
|
|
_data = nullptr;
|
|
|
|
}
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2020-08-31 23:09:42 +08:00
|
|
|
return ret;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::initWithPVRv2Data(uint8_t* data, ssize_t dataLen, bool ownData)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
int blockSize = 0, widthBlocks = 0, heightBlocks = 0;
|
|
|
|
int width = 0, height = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
// Cast first sizeof(PVRTexHeader) bytes of data stream as PVRTexHeader
|
|
|
|
const PVRv2TexHeader* header = static_cast<const PVRv2TexHeader*>(static_cast<const void*>(data));
|
|
|
|
|
|
|
|
// Make sure that tag is in correct formatting
|
2019-11-23 20:27:39 +08:00
|
|
|
if (memcmp(&header->pvrTag, gPVRTexIdentifier, strlen(gPVRTexIdentifier)) != 0)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
Configuration* configuration = Configuration::getInstance();
|
|
|
|
|
|
|
|
// can not detect the premultiplied alpha from pvr file, use _PVRHaveAlphaPremultiplied instead.
|
2020-11-16 12:21:27 +08:00
|
|
|
_hasPremultipliedAlpha = isCompressedImageHavePMA(CompressedImagePMAFlag::PVR);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2022-07-15 19:17:01 +08:00
|
|
|
unsigned int flags = AX_SWAP_INT32_LITTLE_TO_HOST(header->flags);
|
2019-11-23 20:27:39 +08:00
|
|
|
PVR2TexturePixelFormat formatFlags = static_cast<PVR2TexturePixelFormat>(flags & PVR_TEXTURE_FLAG_TYPE_MASK);
|
2021-12-25 10:04:45 +08:00
|
|
|
bool flipped = (flags & (unsigned int)PVR2TextureFlag::VerticalFlip) ? true : false;
|
2019-11-23 20:27:39 +08:00
|
|
|
if (flipped)
|
|
|
|
{
|
|
|
|
CCLOG("cocos2d: WARNING: Image is flipped. Regenerate it using PVRTexTool");
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
if (!configuration->supportsNPOT() && (static_cast<int>(header->width) != ccNextPOT(header->width) ||
|
|
|
|
static_cast<int>(header->height) != ccNextPOT(header->height)))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
CCLOG("cocos2d: ERROR: Loading an NPOT texture (%dx%d) but is not supported on this device", header->width,
|
|
|
|
header->height);
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
if (!testFormatForPvr2TCSupport(formatFlags))
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
CCLOG("cocos2d: WARNING: Unsupported PVR Pixel Format: 0x%02X. Re-encode it with a OpenGL pixel format variant",
|
|
|
|
(int)formatFlags);
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (v2_pixel_formathash.find(formatFlags) == v2_pixel_formathash.end())
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
CCLOG("cocos2d: WARNING: Unsupported PVR Pixel Format: 0x%02X. Re-encode it with a OpenGL pixel format variant",
|
|
|
|
(int)formatFlags);
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2020-09-25 11:07:56 +08:00
|
|
|
auto pixelFormat = getDevicePVRPixelFormat(v2_pixel_formathash.at(formatFlags));
|
2021-12-25 10:04:45 +08:00
|
|
|
auto& info = backend::PixelFormatUtils::getFormatDescriptor(pixelFormat);
|
|
|
|
int bpp = info.bpp;
|
2020-09-25 11:07:56 +08:00
|
|
|
if (!bpp)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
CCLOG("cocos2d: WARNING: Unsupported PVR Pixel Format: 0x%02X. Re-encode it with a OpenGL pixel format variant",
|
|
|
|
(int)formatFlags);
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = pixelFormat;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
// Reset num of mipmaps
|
2019-11-23 20:27:39 +08:00
|
|
|
_numberOfMipmaps = 0;
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
// Get size of mipmap
|
2022-07-15 19:17:01 +08:00
|
|
|
_width = width = AX_SWAP_INT32_LITTLE_TO_HOST(header->width);
|
|
|
|
_height = height = AX_SWAP_INT32_LITTLE_TO_HOST(header->height);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
// Move by size of header
|
2020-08-31 21:04:47 +08:00
|
|
|
const int pixelOffset = sizeof(PVRv2TexHeader);
|
2021-12-25 10:04:45 +08:00
|
|
|
uint8_t* pixelData = data + pixelOffset;
|
2020-08-31 21:04:47 +08:00
|
|
|
|
|
|
|
int dataOffset = 0, dataSize = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
// Get ptr to where data starts..
|
2022-07-15 19:17:01 +08:00
|
|
|
int dataLength = AX_SWAP_INT32_LITTLE_TO_HOST(header->dataLength);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// Calculate the data size for each texture level and respect the minimum number of blocks
|
|
|
|
while (dataOffset < dataLength)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
switch (formatFlags)
|
|
|
|
{
|
|
|
|
case PVR2TexturePixelFormat::PVRTC2BPP_RGBA:
|
|
|
|
if (!Configuration::getInstance()->supportsPVRTC())
|
|
|
|
{
|
|
|
|
CCLOG("cocos2d: Hardware PVR decoder not present. Using software decoder");
|
|
|
|
_unpack = true;
|
|
|
|
_mipmaps[_numberOfMipmaps].len = width * height * 4;
|
|
|
|
_mipmaps[_numberOfMipmaps].address = (uint8_t*)malloc(width * height * 4);
|
|
|
|
PVRTDecompressPVRTC(pixelData + dataOffset, width, height, _mipmaps[_numberOfMipmaps].address, true);
|
|
|
|
bpp = 2;
|
|
|
|
}
|
|
|
|
blockSize = 8 * 4; // Pixel by pixel block size for 2bpp
|
|
|
|
widthBlocks = width / 8;
|
|
|
|
heightBlocks = height / 4;
|
|
|
|
break;
|
|
|
|
case PVR2TexturePixelFormat::PVRTC4BPP_RGBA:
|
|
|
|
if (!Configuration::getInstance()->supportsPVRTC())
|
|
|
|
{
|
|
|
|
CCLOG("cocos2d: Hardware PVR decoder not present. Using software decoder");
|
|
|
|
_unpack = true;
|
|
|
|
_mipmaps[_numberOfMipmaps].len = width * height * 4;
|
|
|
|
_mipmaps[_numberOfMipmaps].address = (uint8_t*)malloc(width * height * 4);
|
|
|
|
PVRTDecompressPVRTC(pixelData + dataOffset, width, height, _mipmaps[_numberOfMipmaps].address, false);
|
|
|
|
bpp = 4;
|
|
|
|
}
|
|
|
|
blockSize = 4 * 4; // Pixel by pixel block size for 4bpp
|
|
|
|
widthBlocks = width / 4;
|
|
|
|
heightBlocks = height / 4;
|
|
|
|
break;
|
|
|
|
case PVR2TexturePixelFormat::BGRA8888:
|
|
|
|
if (!Configuration::getInstance()->supportsBGRA8888())
|
|
|
|
{
|
|
|
|
CCLOG("cocos2d: Image. BGRA8888 not supported on this device");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
blockSize = 1;
|
|
|
|
widthBlocks = width;
|
|
|
|
heightBlocks = height;
|
|
|
|
break;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// Clamp to minimum number of blocks
|
|
|
|
if (widthBlocks < 2)
|
|
|
|
{
|
|
|
|
widthBlocks = 2;
|
|
|
|
}
|
|
|
|
if (heightBlocks < 2)
|
|
|
|
{
|
|
|
|
heightBlocks = 2;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
dataSize = widthBlocks * heightBlocks * ((blockSize * bpp) / 8);
|
2019-11-23 20:27:39 +08:00
|
|
|
int packetLength = (dataLength - dataOffset);
|
2021-12-25 10:04:45 +08:00
|
|
|
packetLength = packetLength > dataSize ? dataSize : packetLength;
|
|
|
|
|
|
|
|
// Make record to the mipmaps array and increment counter
|
|
|
|
if (!_unpack)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2020-08-31 21:04:47 +08:00
|
|
|
_mipmaps[_numberOfMipmaps].address = pixelData + dataOffset;
|
2021-12-25 10:04:45 +08:00
|
|
|
_mipmaps[_numberOfMipmaps].len = packetLength;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
_numberOfMipmaps++;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
dataOffset += packetLength;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
// Update width and height to the next lower power of two
|
|
|
|
width = MAX(width >> 1, 1);
|
2019-11-23 20:27:39 +08:00
|
|
|
height = MAX(height >> 1, 1);
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
if (!_unpack)
|
|
|
|
{ // hardware decoder, hold data directly
|
2020-08-31 23:09:42 +08:00
|
|
|
forwardPixels(data, dataLen, pixelOffset, ownData);
|
2020-08-31 21:04:47 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
_data = _mipmaps[0].address;
|
2019-11-23 20:27:39 +08:00
|
|
|
_dataLen = _mipmaps[0].len;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::initWithPVRv3Data(uint8_t* data, ssize_t dataLen, bool ownData)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (static_cast<size_t>(dataLen) < sizeof(PVRv3TexHeader))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
const PVRv3TexHeader* header = static_cast<const PVRv3TexHeader*>(static_cast<const void*>(data));
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// validate version
|
2022-07-15 19:17:01 +08:00
|
|
|
if (AX_SWAP_INT32_BIG_TO_HOST(header->version) != 0x50565203)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
CCLOG("cocos2d: WARNING: pvr file version mismatch");
|
|
|
|
return false;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// parse pixel format
|
|
|
|
PVR3TexturePixelFormat pixelFormat = static_cast<PVR3TexturePixelFormat>(header->pixelFormat);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
if (!testFormatForPvr3TCSupport(pixelFormat))
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
CCLOG(
|
|
|
|
"cocos2d: WARNING: Unsupported PVR Pixel Format: 0x%016llX. Re-encode it with a OpenGL pixel format "
|
|
|
|
"variant",
|
|
|
|
static_cast<unsigned long long>(pixelFormat));
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (v3_pixel_formathash.find(pixelFormat) == v3_pixel_formathash.end())
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
CCLOG(
|
|
|
|
"cocos2d: WARNING: Unsupported PVR Pixel Format: 0x%016llX. Re-encode it with a OpenGL pixel format "
|
|
|
|
"variant",
|
|
|
|
static_cast<unsigned long long>(pixelFormat));
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-09-25 11:07:56 +08:00
|
|
|
auto finalPixelFormat = getDevicePVRPixelFormat(v3_pixel_formathash.at(pixelFormat));
|
2021-12-25 10:04:45 +08:00
|
|
|
auto& info = backend::PixelFormatUtils::getFormatDescriptor(finalPixelFormat);
|
|
|
|
int bpp = info.bpp;
|
2020-09-25 11:07:56 +08:00
|
|
|
if (!info.bpp)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
CCLOG(
|
|
|
|
"cocos2d: WARNING: Unsupported PVR Pixel Format: 0x%016llX. Re-encode it with a OpenGL pixel format "
|
|
|
|
"variant",
|
|
|
|
static_cast<unsigned long long>(pixelFormat));
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = finalPixelFormat;
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// flags
|
2022-07-15 19:17:01 +08:00
|
|
|
int flags = AX_SWAP_INT32_LITTLE_TO_HOST(header->flags);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// PVRv3 specifies premultiply alpha in a flag -- should always respect this in PVRv3 files
|
|
|
|
if (flags & (unsigned int)PVR3TextureFlag::PremultipliedAlpha)
|
|
|
|
{
|
|
|
|
_hasPremultipliedAlpha = true;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// sizing
|
2022-07-15 19:17:01 +08:00
|
|
|
int width = AX_SWAP_INT32_LITTLE_TO_HOST(header->width);
|
|
|
|
int height = AX_SWAP_INT32_LITTLE_TO_HOST(header->height);
|
2021-12-25 10:04:45 +08:00
|
|
|
_width = width;
|
|
|
|
_height = height;
|
2020-08-31 21:04:47 +08:00
|
|
|
|
|
|
|
const int pixelOffset = (sizeof(PVRv3TexHeader) + header->metadataLength);
|
2021-12-25 10:04:45 +08:00
|
|
|
uint8_t* pixelData = data + pixelOffset;
|
|
|
|
int pixelLen = dataLen - pixelOffset;
|
2020-08-31 21:04:47 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
int dataOffset = 0, dataSize = 0;
|
|
|
|
int blockSize = 0, widthBlocks = 0, heightBlocks = 0;
|
2020-08-31 21:04:47 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
_numberOfMipmaps = header->numberOfMipmaps;
|
2021-12-25 10:04:45 +08:00
|
|
|
CCASSERT(_numberOfMipmaps < MIPMAP_MAX,
|
2022-07-15 19:17:01 +08:00
|
|
|
"Image: Maximum number of mimpaps reached. Increase the AX_MIPMAP_MAX value");
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
for (int i = 0; i < _numberOfMipmaps; i++)
|
|
|
|
{
|
|
|
|
switch ((PVR3TexturePixelFormat)pixelFormat)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
case PVR3TexturePixelFormat::PVRTC2BPP_RGB:
|
|
|
|
case PVR3TexturePixelFormat::PVRTC2BPP_RGBA:
|
|
|
|
if (!Configuration::getInstance()->supportsPVRTC())
|
|
|
|
{
|
|
|
|
CCLOG("cocos2d: Hardware PVR decoder not present. Using software decoder");
|
|
|
|
_unpack = true;
|
|
|
|
_mipmaps[i].len = width * height * 4;
|
|
|
|
_mipmaps[i].address = (uint8_t*)malloc(width * height * 4);
|
|
|
|
PVRTDecompressPVRTC(pixelData + dataOffset, width, height, _mipmaps[i].address, true);
|
|
|
|
bpp = 2;
|
|
|
|
}
|
|
|
|
blockSize = 8 * 4; // Pixel by pixel block size for 2bpp
|
|
|
|
widthBlocks = width / 8;
|
|
|
|
heightBlocks = height / 4;
|
|
|
|
break;
|
|
|
|
case PVR3TexturePixelFormat::PVRTC4BPP_RGB:
|
|
|
|
case PVR3TexturePixelFormat::PVRTC4BPP_RGBA:
|
|
|
|
if (!Configuration::getInstance()->supportsPVRTC())
|
|
|
|
{
|
|
|
|
CCLOG("cocos2d: Hardware PVR decoder not present. Using software decoder");
|
|
|
|
_unpack = true;
|
|
|
|
_mipmaps[i].len = width * height * 4;
|
|
|
|
_mipmaps[i].address = (uint8_t*)malloc(width * height * 4);
|
|
|
|
PVRTDecompressPVRTC(pixelData + dataOffset, width, height, _mipmaps[i].address, false);
|
|
|
|
bpp = 4;
|
|
|
|
}
|
|
|
|
blockSize = 4 * 4; // Pixel by pixel block size for 4bpp
|
|
|
|
widthBlocks = width / 4;
|
|
|
|
heightBlocks = height / 4;
|
|
|
|
break;
|
|
|
|
case PVR3TexturePixelFormat::ETC1:
|
|
|
|
if (!Configuration::getInstance()->supportsETC1())
|
|
|
|
{
|
|
|
|
CCLOG("cocos2d: Hardware ETC1 decoder not present. Using software decoder");
|
|
|
|
const int bytePerPixel = 4;
|
|
|
|
_unpack = true;
|
|
|
|
_mipmaps[i].len = width * height * bytePerPixel;
|
|
|
|
_mipmaps[i].address = (uint8_t*)malloc(width * height * bytePerPixel);
|
|
|
|
if (etc2_decode_image(ETC2_RGB_NO_MIPMAPS, pixelData + dataOffset,
|
|
|
|
static_cast<etc1_byte*>(_mipmaps[i].address), width, height) != 0)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
blockSize = 4 * 4; // Pixel by pixel block size for 4bpp
|
|
|
|
widthBlocks = width / 4;
|
|
|
|
heightBlocks = height / 4;
|
|
|
|
break;
|
|
|
|
case PVR3TexturePixelFormat::BGRA8888:
|
|
|
|
if (!Configuration::getInstance()->supportsBGRA8888())
|
|
|
|
{
|
|
|
|
CCLOG("cocos2d: Image. BGRA8888 not supported on this device");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
blockSize = 1;
|
|
|
|
widthBlocks = width;
|
|
|
|
heightBlocks = height;
|
|
|
|
break;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// Clamp to minimum number of blocks
|
|
|
|
if (widthBlocks < 2)
|
|
|
|
{
|
|
|
|
widthBlocks = 2;
|
|
|
|
}
|
|
|
|
if (heightBlocks < 2)
|
|
|
|
{
|
|
|
|
heightBlocks = 2;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
dataSize = widthBlocks * heightBlocks * ((blockSize * bpp) / 8);
|
2020-08-31 21:04:47 +08:00
|
|
|
auto packetLength = pixelLen - dataOffset;
|
2021-12-25 10:04:45 +08:00
|
|
|
packetLength = packetLength > dataSize ? dataSize : packetLength;
|
|
|
|
|
|
|
|
if (!_unpack)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2020-08-31 21:04:47 +08:00
|
|
|
_mipmaps[i].address = pixelData + dataOffset;
|
2021-12-25 10:04:45 +08:00
|
|
|
_mipmaps[i].len = static_cast<int>(packetLength);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
dataOffset += packetLength;
|
2020-08-31 21:04:47 +08:00
|
|
|
CCASSERT(dataOffset <= pixelLen, "Image: Invalid length");
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
width = MAX(width >> 1, 1);
|
2019-11-23 20:27:39 +08:00
|
|
|
height = MAX(height >> 1, 1);
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
if (!_unpack)
|
|
|
|
{
|
2020-08-31 23:09:42 +08:00
|
|
|
forwardPixels(data, dataLen, pixelOffset, ownData);
|
2020-08-31 21:04:47 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
_data = _mipmaps[0].address;
|
2019-11-23 20:27:39 +08:00
|
|
|
_dataLen = _mipmaps[0].len;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-09-01 14:57:18 +08:00
|
|
|
bool Image::initWithETCData(uint8_t* data, ssize_t dataLen, bool ownData)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
const etc1_byte* header = static_cast<const etc1_byte*>(data);
|
2022-04-25 19:11:58 +08:00
|
|
|
uint32_t pixelOffset;
|
2021-12-25 10:04:45 +08:00
|
|
|
// check the data
|
2022-04-25 19:11:58 +08:00
|
|
|
if (etc1_pkm_is_valid(header))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-04-25 19:11:58 +08:00
|
|
|
_width = etc1_pkm_get_width(header);
|
|
|
|
_height = etc1_pkm_get_height(header);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2022-04-25 19:11:58 +08:00
|
|
|
if (0 == _width || 0 == _height)
|
|
|
|
return false;
|
|
|
|
pixelOffset = ETC_PKM_HEADER_SIZE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // we can safe trait as KTX v1 header
|
|
|
|
auto header = (KTXv1Header*)data;
|
|
|
|
_width = header->pixelWidth;
|
|
|
|
_height = header->pixelHeight;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2022-04-25 19:11:58 +08:00
|
|
|
if (0 == _width || 0 == _height)
|
|
|
|
return false;
|
|
|
|
pixelOffset = KTX_V1_HEADER_SIZE + header->bytesOfKeyValueData + 4;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2020-08-31 21:04:47 +08:00
|
|
|
// GL_ETC1_RGB8_OES is not available in any desktop GL extension but the compression
|
2021-12-25 10:04:45 +08:00
|
|
|
// format is forwards compatible so just use the ETC2 format.
|
2020-08-31 21:04:47 +08:00
|
|
|
backend::PixelFormat compressedFormat;
|
2020-09-01 11:43:03 +08:00
|
|
|
if (Configuration::getInstance()->supportsETC1())
|
|
|
|
compressedFormat = backend::PixelFormat::ETC1;
|
2020-08-31 21:04:47 +08:00
|
|
|
else if (Configuration::getInstance()->supportsETC2())
|
|
|
|
compressedFormat = backend::PixelFormat::ETC2_RGB;
|
|
|
|
else
|
|
|
|
compressedFormat = backend::PixelFormat::NONE;
|
|
|
|
|
|
|
|
if (compressedFormat != backend::PixelFormat::NONE)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2020-08-31 21:04:47 +08:00
|
|
|
_pixelFormat = compressedFormat;
|
2022-04-25 19:11:58 +08:00
|
|
|
forwardPixels(data, dataLen, pixelOffset, ownData);
|
2019-11-23 20:27:39 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
CCLOG("cocos2d: Hardware ETC1 decoder not present. Using software decoder");
|
|
|
|
|
2020-08-31 21:04:47 +08:00
|
|
|
_dataLen = _width * _height * 4;
|
2021-12-25 10:04:45 +08:00
|
|
|
_data = static_cast<uint8_t*>(malloc(_dataLen));
|
2022-04-25 19:11:58 +08:00
|
|
|
if (etc2_decode_image(ETC2_RGB_NO_MIPMAPS, static_cast<const uint8_t*>(data) + pixelOffset,
|
2021-12-25 10:04:45 +08:00
|
|
|
static_cast<etc2_byte*>(_data), _width, _height) == 0)
|
|
|
|
{ // if it is not gles or device do not support ETC1, decode texture by software
|
|
|
|
// directly decode ETC1_RGB to RGBA8888
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::RGBA8;
|
2020-09-01 11:43:03 +08:00
|
|
|
return true;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2020-09-01 11:43:03 +08:00
|
|
|
// software decode fail, release pixels data
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_SAFE_FREE(_data);
|
2020-09-01 11:43:03 +08:00
|
|
|
_dataLen = 0;
|
|
|
|
return false;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-01 14:57:18 +08:00
|
|
|
bool Image::initWithETC2Data(uint8_t* data, ssize_t dataLen, bool ownData)
|
2020-08-31 21:04:47 +08:00
|
|
|
{
|
|
|
|
const etc2_byte* header = static_cast<const etc2_byte*>(data);
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
do
|
|
|
|
{
|
2022-04-25 19:11:58 +08:00
|
|
|
uint32_t format, pixelOffset;
|
2021-12-25 10:04:45 +08:00
|
|
|
// check the data
|
2022-04-25 19:11:58 +08:00
|
|
|
if (etc2_pkm_is_valid(header))
|
|
|
|
{
|
2020-08-31 21:04:47 +08:00
|
|
|
|
2022-04-25 19:11:58 +08:00
|
|
|
_width = etc2_pkm_get_width(header);
|
|
|
|
_height = etc2_pkm_get_height(header);
|
2020-08-31 21:04:47 +08:00
|
|
|
|
2022-04-25 19:11:58 +08:00
|
|
|
if (0 == _width || 0 == _height)
|
|
|
|
break;
|
|
|
|
|
|
|
|
format = etc2_pkm_get_format(header);
|
|
|
|
pixelOffset = ETC2_PKM_HEADER_SIZE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // we can safe trait as KTX v1 header
|
|
|
|
auto header = (KTXv1Header*)data;
|
|
|
|
_width = header->pixelWidth;
|
|
|
|
_height = header->pixelHeight;
|
2020-08-31 21:04:47 +08:00
|
|
|
|
2022-04-25 19:11:58 +08:00
|
|
|
if (0 == _width || 0 == _height)
|
|
|
|
break;
|
|
|
|
|
|
|
|
format = header->glInternalFormat == KTXv1Header::InternalFormat::ETC2_RGBA8 ? ETC2_RGBA_NO_MIPMAPS
|
|
|
|
: ETC2_RGB_NO_MIPMAPS;
|
|
|
|
pixelOffset = KTX_V1_HEADER_SIZE + header->bytesOfKeyValueData + 4;
|
|
|
|
}
|
2020-08-31 21:04:47 +08:00
|
|
|
|
2020-11-16 12:21:27 +08:00
|
|
|
// We only support ETC2_RGBA_NO_MIPMAPS and ETC2_RGB_NO_MIPMAPS
|
|
|
|
assert(format == ETC2_RGBA_NO_MIPMAPS || format == ETC2_RGB_NO_MIPMAPS);
|
2020-02-12 20:24:29 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (Configuration::getInstance()->supportsETC2())
|
|
|
|
{
|
|
|
|
_pixelFormat =
|
|
|
|
format == ETC2_RGBA_NO_MIPMAPS ? backend::PixelFormat::ETC2_RGBA : backend::PixelFormat::ETC2_RGB;
|
2020-08-31 21:04:47 +08:00
|
|
|
|
2022-04-25 19:11:58 +08:00
|
|
|
forwardPixels(data, dataLen, pixelOffset, ownData);
|
2020-11-16 12:21:27 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else
|
|
|
|
{
|
2020-11-16 12:21:27 +08:00
|
|
|
CCLOG("cocos2d: Hardware ETC2 decoder not present. Using software decoder");
|
|
|
|
|
|
|
|
// if device do not support ETC2, decode texture by software
|
|
|
|
// etc2_decode_image always decode to RGBA8888
|
|
|
|
_dataLen = _width * _height * 4;
|
2021-12-25 10:04:45 +08:00
|
|
|
_data = static_cast<uint8_t*>(malloc(_dataLen));
|
2022-04-25 19:11:58 +08:00
|
|
|
if (UTILS_UNLIKELY(etc2_decode_image(format, static_cast<const uint8_t*>(data) + pixelOffset,
|
2021-12-25 10:04:45 +08:00
|
|
|
static_cast<etc2_byte*>(_data), _width, _height) != 0))
|
2020-11-16 12:21:27 +08:00
|
|
|
{
|
|
|
|
// software decode fail, release pixels data
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_SAFE_FREE(_data);
|
2020-11-16 12:21:27 +08:00
|
|
|
_dataLen = 0;
|
|
|
|
break;
|
|
|
|
}
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::RGBA8;
|
2020-08-31 21:04:47 +08:00
|
|
|
}
|
|
|
|
|
2020-11-16 12:21:27 +08:00
|
|
|
_hasPremultipliedAlpha = isCompressedImageHavePMA(CompressedImagePMAFlag::ETC2);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
} while (false);
|
|
|
|
|
|
|
|
return false;
|
2020-08-31 21:04:47 +08:00
|
|
|
}
|
|
|
|
|
2020-09-01 14:57:18 +08:00
|
|
|
bool Image::initWithASTCData(uint8_t* data, ssize_t dataLen, bool ownData)
|
2020-02-12 20:24:29 +08:00
|
|
|
{
|
2021-06-01 23:43:28 +08:00
|
|
|
astc_header* hdr = (astc_header*)data;
|
2020-02-12 20:24:29 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
do
|
|
|
|
{
|
2021-06-01 23:43:28 +08:00
|
|
|
// Ensure these are not zero to avoid div by zero
|
2021-12-25 10:04:45 +08:00
|
|
|
unsigned int block_x = (std::max)((unsigned int)hdr->block_x, 1u);
|
|
|
|
unsigned int block_y = (std::max)((unsigned int)hdr->block_y, 1u);
|
2021-06-01 23:43:28 +08:00
|
|
|
// unsigned int block_z = std::max((unsigned int) hdr->block_z, 1u);
|
2020-02-12 20:24:29 +08:00
|
|
|
|
2021-06-01 23:43:28 +08:00
|
|
|
unsigned int dim_x = astc_unpack_bytes(hdr->dim_x[0], hdr->dim_x[1], hdr->dim_x[2], 0);
|
|
|
|
unsigned int dim_y = astc_unpack_bytes(hdr->dim_y[0], hdr->dim_y[1], hdr->dim_y[2], 0);
|
|
|
|
// unsigned int dim_z = astc_unpack_bytes(hdr->dim_z[0], hdr->dim_z[1], hdr->dim_z[2], 0);
|
|
|
|
|
|
|
|
if (dim_x == 0 || dim_y == 0)
|
2020-11-16 12:21:27 +08:00
|
|
|
break;
|
2020-02-12 20:24:29 +08:00
|
|
|
|
2021-06-01 23:43:28 +08:00
|
|
|
_width = dim_x;
|
|
|
|
_height = dim_y;
|
2020-02-12 20:24:29 +08:00
|
|
|
|
2021-06-01 23:43:28 +08:00
|
|
|
if (block_x < 4 || block_y < 4)
|
2020-02-12 20:24:29 +08:00
|
|
|
{
|
2020-11-16 12:21:27 +08:00
|
|
|
CCLOG("cocos2d: The ASTC block with and height should be >= 4");
|
|
|
|
break;
|
2020-02-12 20:24:29 +08:00
|
|
|
}
|
2020-11-16 12:21:27 +08:00
|
|
|
|
|
|
|
if (Configuration::getInstance()->supportsASTC())
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (block_x == 4 && block_y == 4)
|
|
|
|
{
|
2020-11-16 12:21:27 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::ASTC4x4;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (block_x == 5 && block_y == 5)
|
|
|
|
{
|
2020-11-16 12:21:27 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::ASTC5x5;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (block_x == 6 && block_y == 6)
|
|
|
|
{
|
2020-11-16 12:21:27 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::ASTC6x6;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (block_x == 8 && block_y == 5)
|
|
|
|
{
|
2020-11-16 12:21:27 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::ASTC8x5;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (block_x == 8 && block_y == 6)
|
|
|
|
{
|
2020-11-16 12:21:27 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::ASTC8x6;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (block_x == 8 && block_y == 8)
|
2020-11-16 12:21:27 +08:00
|
|
|
{
|
|
|
|
_pixelFormat = backend::PixelFormat::ASTC8x8;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (block_x == 10 && block_y == 5)
|
|
|
|
{
|
2020-11-16 12:21:27 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::ASTC10x5;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2020-11-16 12:21:27 +08:00
|
|
|
forwardPixels(data, dataLen, ASTC_HEAD_SIZE, ownData);
|
2020-09-25 11:07:56 +08:00
|
|
|
}
|
2020-11-16 12:21:27 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
CCLOG("cocos2d: Hardware ASTC decoder not present. Using software decoder");
|
2020-08-31 21:04:47 +08:00
|
|
|
|
2020-11-16 12:21:27 +08:00
|
|
|
_dataLen = _width * _height * 4;
|
2021-06-01 23:43:28 +08:00
|
|
|
_data = static_cast<uint8_t*>(malloc(_dataLen));
|
|
|
|
if (UTILS_UNLIKELY(astc_decompress_image(static_cast<const uint8_t*>(data) + ASTC_HEAD_SIZE,
|
2021-12-25 10:04:45 +08:00
|
|
|
dataLen - ASTC_HEAD_SIZE, _data, _width, _height, block_x,
|
|
|
|
block_y) != 0))
|
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_SAFE_FREE(_data);
|
2020-11-16 12:21:27 +08:00
|
|
|
_dataLen = 0;
|
|
|
|
break;
|
|
|
|
}
|
2020-02-12 20:24:29 +08:00
|
|
|
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::RGBA8;
|
2020-02-12 20:24:29 +08:00
|
|
|
}
|
|
|
|
|
2020-11-16 12:21:27 +08:00
|
|
|
_hasPremultipliedAlpha = isCompressedImageHavePMA(CompressedImagePMAFlag::ASTC);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
} while (false);
|
|
|
|
|
|
|
|
return false;
|
2020-02-12 20:24:29 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::initWithS3TCData(uint8_t* data, ssize_t dataLen, bool ownData)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
const uint32_t FOURCC_DXT1 = makeFourCC('D', 'X', 'T', '1');
|
|
|
|
const uint32_t FOURCC_DXT3 = makeFourCC('D', 'X', 'T', '3');
|
|
|
|
const uint32_t FOURCC_DXT5 = makeFourCC('D', 'X', 'T', '5');
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
/* load the .dds file */
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
S3TCTexHeader* header = (S3TCTexHeader*)data;
|
|
|
|
_width = header->ddsd.width;
|
|
|
|
_height = header->ddsd.height;
|
|
|
|
_numberOfMipmaps = MAX(
|
2022-04-25 21:39:49 +08:00
|
|
|
1,
|
|
|
|
header->ddsd.DUMMYUNIONNAMEN2
|
|
|
|
.mipMapCount); // if dds header reports 0 mipmaps, set to 1 to force correct software decoding (if needed).
|
2021-12-25 10:04:45 +08:00
|
|
|
_dataLen = 0;
|
2019-11-23 20:27:39 +08:00
|
|
|
int blockSize = (FOURCC_DXT1 == header->ddsd.DUMMYUNIONNAMEN4.ddpfPixelFormat.fourCC) ? 8 : 16;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
/* calculate the dataLen */
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
int width = _width;
|
2019-11-23 20:27:39 +08:00
|
|
|
int height = _height;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2020-08-31 21:04:47 +08:00
|
|
|
const int pixelOffset = sizeof(S3TCTexHeader);
|
2021-12-25 10:04:45 +08:00
|
|
|
uint8_t* pixelData = data + pixelOffset;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2020-08-31 21:04:47 +08:00
|
|
|
bool hardware = Configuration::getInstance()->supportsS3TC();
|
2019-11-23 20:27:39 +08:00
|
|
|
/* if hardware supports s3tc, set pixelformat before loading mipmaps, to support non-mipmapped textures */
|
2020-08-31 21:04:47 +08:00
|
|
|
if (hardware)
|
2021-12-25 10:04:45 +08:00
|
|
|
{ // decode texture through hardware
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
if (FOURCC_DXT1 == header->ddsd.DUMMYUNIONNAMEN4.ddpfPixelFormat.fourCC)
|
|
|
|
{
|
|
|
|
_pixelFormat = backend::PixelFormat::S3TC_DXT1;
|
|
|
|
}
|
|
|
|
else if (FOURCC_DXT3 == header->ddsd.DUMMYUNIONNAMEN4.ddpfPixelFormat.fourCC)
|
|
|
|
{
|
|
|
|
_pixelFormat = backend::PixelFormat::S3TC_DXT3;
|
|
|
|
}
|
|
|
|
else if (FOURCC_DXT5 == header->ddsd.DUMMYUNIONNAMEN4.ddpfPixelFormat.fourCC)
|
|
|
|
{
|
|
|
|
_pixelFormat = backend::PixelFormat::S3TC_DXT5;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // will software decode
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::RGBA8;
|
2020-08-31 21:04:47 +08:00
|
|
|
|
|
|
|
// prepare data for software decompress
|
|
|
|
for (int i = 0; i < _numberOfMipmaps && (width || height); ++i)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (width == 0)
|
|
|
|
width = 1;
|
|
|
|
if (height == 0)
|
|
|
|
height = 1;
|
2020-08-31 21:04:47 +08:00
|
|
|
|
|
|
|
_dataLen += (height * width * 4);
|
|
|
|
|
|
|
|
width >>= 1;
|
|
|
|
height >>= 1;
|
|
|
|
}
|
2020-09-01 14:57:18 +08:00
|
|
|
_data = static_cast<uint8_t*>(malloc(_dataLen));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
/* load the mipmaps */
|
|
|
|
int encodeOffset = 0;
|
|
|
|
int decodeOffset = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
width = _width;
|
|
|
|
height = _height;
|
|
|
|
|
|
|
|
for (int i = 0; i < _numberOfMipmaps && (width || height); ++i)
|
|
|
|
{
|
|
|
|
if (width == 0)
|
|
|
|
width = 1;
|
|
|
|
if (height == 0)
|
|
|
|
height = 1;
|
|
|
|
|
|
|
|
int size = ((width + 3) / 4) * ((height + 3) / 4) * blockSize;
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
if (Configuration::getInstance()->supportsS3TC())
|
2021-12-25 10:04:45 +08:00
|
|
|
{ // decode texture through hardware
|
|
|
|
_mipmaps[i].address = (uint8_t*)pixelData + encodeOffset;
|
|
|
|
_mipmaps[i].len = size;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
else
|
2021-12-25 10:04:45 +08:00
|
|
|
{ // if it is not gles or device do not support S3TC, decode texture by software
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
CCLOG("cocos2d: Hardware S3TC decoder not present. Using software decoder");
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
int bytePerPixel = 4;
|
2019-11-23 20:27:39 +08:00
|
|
|
unsigned int stride = width * bytePerPixel;
|
|
|
|
|
2020-09-01 14:57:18 +08:00
|
|
|
std::vector<uint8_t> decodeImageData(stride * height);
|
2019-11-23 20:27:39 +08:00
|
|
|
if (FOURCC_DXT1 == header->ddsd.DUMMYUNIONNAMEN4.ddpfPixelFormat.fourCC)
|
|
|
|
{
|
|
|
|
s3tc_decode(pixelData + encodeOffset, &decodeImageData[0], width, height, S3TCDecodeFlag::DXT1);
|
|
|
|
}
|
|
|
|
else if (FOURCC_DXT3 == header->ddsd.DUMMYUNIONNAMEN4.ddpfPixelFormat.fourCC)
|
|
|
|
{
|
|
|
|
s3tc_decode(pixelData + encodeOffset, &decodeImageData[0], width, height, S3TCDecodeFlag::DXT3);
|
|
|
|
}
|
|
|
|
else if (FOURCC_DXT5 == header->ddsd.DUMMYUNIONNAMEN4.ddpfPixelFormat.fourCC)
|
|
|
|
{
|
|
|
|
s3tc_decode(pixelData + encodeOffset, &decodeImageData[0], width, height, S3TCDecodeFlag::DXT5);
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
_mipmaps[i].address = (uint8_t*)_data + decodeOffset;
|
|
|
|
_mipmaps[i].len = (stride * height);
|
|
|
|
memcpy((void*)_mipmaps[i].address, (void*)&decodeImageData[0], _mipmaps[i].len);
|
2019-11-23 20:27:39 +08:00
|
|
|
decodeOffset += stride * height;
|
|
|
|
}
|
2020-08-31 21:04:47 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
encodeOffset += size;
|
|
|
|
width >>= 1;
|
|
|
|
height >>= 1;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
/* end load the mipmaps */
|
2020-08-31 21:04:47 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (hardware)
|
|
|
|
{
|
2020-08-31 23:09:42 +08:00
|
|
|
forwardPixels(data, dataLen, pixelOffset, ownData);
|
2020-08-31 21:04:47 +08:00
|
|
|
}
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::initWithATITCData(uint8_t* data, ssize_t dataLen, bool ownData)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
/* load the .ktx file */
|
2022-04-25 19:11:58 +08:00
|
|
|
KTXv1Header* header = (KTXv1Header*)data;
|
|
|
|
_width = header->pixelWidth;
|
|
|
|
_height = header->pixelHeight;
|
|
|
|
_numberOfMipmaps = header->numberOfMipmapLevels;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
int blockSize = 0;
|
|
|
|
switch (header->glInternalFormat)
|
|
|
|
{
|
2022-04-25 21:39:49 +08:00
|
|
|
case KTXv1Header::InternalFormat::ATC_RGB_AMD:
|
2021-12-25 10:04:45 +08:00
|
|
|
blockSize = 8;
|
|
|
|
break;
|
2022-04-25 21:39:49 +08:00
|
|
|
case KTXv1Header::InternalFormat::ATC_RGBA_EXPLICIT_ALPHA_AMD:
|
2021-12-25 10:04:45 +08:00
|
|
|
blockSize = 16;
|
|
|
|
break;
|
2022-04-25 21:39:49 +08:00
|
|
|
case KTXv1Header::InternalFormat::ATC_RGBA_INTERPOLATED_ALPHA_AMD:
|
2021-12-25 10:04:45 +08:00
|
|
|
blockSize = 16;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
/* pixelData point to the compressed data address */
|
2022-04-25 19:11:58 +08:00
|
|
|
int pixelOffset = KTX_V1_HEADER_SIZE + header->bytesOfKeyValueData + 4;
|
2021-12-25 10:04:45 +08:00
|
|
|
uint8_t* pixelData = (uint8_t*)data + pixelOffset;
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
/* calculate the dataLen */
|
2021-12-25 10:04:45 +08:00
|
|
|
int width = _width;
|
2019-11-23 20:27:39 +08:00
|
|
|
int height = _height;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2020-08-31 21:04:47 +08:00
|
|
|
bool hardware = Configuration::getInstance()->supportsATITC();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (hardware) // compressed data length
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2020-08-31 21:04:47 +08:00
|
|
|
CCLOG("this is atitc H decode");
|
|
|
|
|
|
|
|
switch (header->glInternalFormat)
|
|
|
|
{
|
2022-04-25 21:39:49 +08:00
|
|
|
case KTXv1Header::InternalFormat::ATC_RGB_AMD:
|
2020-08-31 21:04:47 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::ATC_RGB;
|
|
|
|
break;
|
2022-04-25 21:39:49 +08:00
|
|
|
case KTXv1Header::InternalFormat::ATC_RGBA_EXPLICIT_ALPHA_AMD:
|
2020-08-31 21:04:47 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::ATC_EXPLICIT_ALPHA;
|
|
|
|
break;
|
2022-04-25 21:39:49 +08:00
|
|
|
case KTXv1Header::InternalFormat::ATC_RGBA_INTERPOLATED_ALPHA_AMD:
|
2020-08-31 21:04:47 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::ATC_INTERPOLATED_ALPHA;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else // decompressed data length
|
|
|
|
{ /* if it is not gles or device do not support ATITC, decode texture by software */
|
2020-08-31 21:04:47 +08:00
|
|
|
|
|
|
|
CCLOG("cocos2d: Hardware ATITC decoder not present. Using software decoder");
|
|
|
|
|
2020-09-25 11:07:56 +08:00
|
|
|
_pixelFormat = backend::PixelFormat::RGBA8;
|
2020-08-31 21:04:47 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
for (int i = 0; i < _numberOfMipmaps && (width || height); ++i)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (width == 0)
|
|
|
|
width = 1;
|
|
|
|
if (height == 0)
|
|
|
|
height = 1;
|
|
|
|
|
|
|
|
_dataLen += (height * width * 4);
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
width >>= 1;
|
|
|
|
height >>= 1;
|
|
|
|
}
|
2020-09-01 14:57:18 +08:00
|
|
|
_data = static_cast<uint8_t*>(malloc(_dataLen));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
/* load the mipmaps */
|
|
|
|
int encodeOffset = 0;
|
|
|
|
int decodeOffset = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
width = _width;
|
|
|
|
height = _height;
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
for (int i = 0; i < _numberOfMipmaps && (width || height); ++i)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (width == 0)
|
|
|
|
width = 1;
|
|
|
|
if (height == 0)
|
|
|
|
height = 1;
|
|
|
|
|
|
|
|
int size = ((width + 3) / 4) * ((height + 3) / 4) * blockSize;
|
|
|
|
|
2020-08-31 21:04:47 +08:00
|
|
|
if (hardware)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
/* decode texture through hardware */
|
2021-12-25 10:04:45 +08:00
|
|
|
_mipmaps[i].address = (uint8_t*)pixelData + encodeOffset;
|
|
|
|
_mipmaps[i].len = size;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
int bytePerPixel = 4;
|
2019-11-23 20:27:39 +08:00
|
|
|
unsigned int stride = width * bytePerPixel;
|
2020-08-31 21:04:47 +08:00
|
|
|
|
2020-09-01 14:57:18 +08:00
|
|
|
std::vector<uint8_t> decodeImageData(stride * height);
|
2019-11-23 20:27:39 +08:00
|
|
|
switch (header->glInternalFormat)
|
|
|
|
{
|
2022-04-25 21:39:49 +08:00
|
|
|
case KTXv1Header::InternalFormat::ATC_RGB_AMD:
|
2021-12-25 10:04:45 +08:00
|
|
|
atitc_decode(pixelData + encodeOffset, &decodeImageData[0], width, height, ATITCDecodeFlag::ATC_RGB);
|
|
|
|
break;
|
2022-04-25 21:39:49 +08:00
|
|
|
case KTXv1Header::InternalFormat::ATC_RGBA_EXPLICIT_ALPHA_AMD:
|
2021-12-25 10:04:45 +08:00
|
|
|
atitc_decode(pixelData + encodeOffset, &decodeImageData[0], width, height,
|
|
|
|
ATITCDecodeFlag::ATC_EXPLICIT_ALPHA);
|
|
|
|
break;
|
2022-04-25 21:39:49 +08:00
|
|
|
case KTXv1Header::InternalFormat::ATC_RGBA_INTERPOLATED_ALPHA_AMD:
|
2021-12-25 10:04:45 +08:00
|
|
|
atitc_decode(pixelData + encodeOffset, &decodeImageData[0], width, height,
|
|
|
|
ATITCDecodeFlag::ATC_INTERPOLATED_ALPHA);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
_mipmaps[i].address = (uint8_t*)_data + decodeOffset;
|
|
|
|
_mipmaps[i].len = (stride * height);
|
|
|
|
memcpy((void*)_mipmaps[i].address, (void*)&decodeImageData[0], _mipmaps[i].len);
|
2019-11-23 20:27:39 +08:00
|
|
|
decodeOffset += stride * height;
|
|
|
|
}
|
|
|
|
|
|
|
|
encodeOffset += (size + 4);
|
|
|
|
width >>= 1;
|
|
|
|
height >>= 1;
|
|
|
|
}
|
|
|
|
/* end load the mipmaps */
|
2020-08-31 21:04:47 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (hardware)
|
|
|
|
{
|
2020-08-31 23:09:42 +08:00
|
|
|
forwardPixels(data, dataLen, pixelOffset, ownData);
|
2020-08-31 21:04:47 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Image::initWithPVRData(uint8_t* data, ssize_t dataLen, bool ownData)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2020-08-31 23:09:42 +08:00
|
|
|
return initWithPVRv2Data(data, dataLen, ownData) || initWithPVRv3Data(data, dataLen, ownData);
|
|
|
|
}
|
|
|
|
|
2020-09-01 14:57:18 +08:00
|
|
|
void Image::forwardPixels(uint8_t* data, ssize_t dataLen, int offset, bool ownData)
|
2020-08-31 23:09:42 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (ownData)
|
|
|
|
{
|
|
|
|
_data = data;
|
2020-08-31 23:09:42 +08:00
|
|
|
_dataLen = dataLen;
|
2021-12-25 10:04:45 +08:00
|
|
|
_offset = offset;
|
2020-08-31 23:09:42 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else
|
|
|
|
{
|
2020-08-31 23:09:42 +08:00
|
|
|
_dataLen = dataLen - offset;
|
2021-12-25 10:04:45 +08:00
|
|
|
_data = (uint8_t*)malloc(_dataLen);
|
2020-08-31 23:09:42 +08:00
|
|
|
memcpy(_data, data + offset, _dataLen);
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2022-07-15 19:17:01 +08:00
|
|
|
#if (AX_TARGET_PLATFORM != AX_PLATFORM_IOS)
|
2021-12-31 12:12:40 +08:00
|
|
|
bool Image::saveToFile(std::string_view filename, bool isToRGB)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
// only support for backend::PixelFormat::RGB8 or backend::PixelFormat::RGBA8 uncompressed data
|
2020-09-25 11:07:56 +08:00
|
|
|
if (isCompressed() || (_pixelFormat != backend::PixelFormat::RGB8 && _pixelFormat != backend::PixelFormat::RGBA8))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
CCLOG(
|
|
|
|
"cocos2d: Image: saveToFile is only support for backend::PixelFormat::RGB8 or backend::PixelFormat::RGBA8 "
|
|
|
|
"uncompressed data for now");
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string fileExtension = FileUtils::getInstance()->getFileExtension(filename);
|
|
|
|
|
|
|
|
if (fileExtension == ".png")
|
|
|
|
{
|
|
|
|
return saveImageToPNG(filename, isToRGB);
|
|
|
|
}
|
|
|
|
else if (fileExtension == ".jpg")
|
|
|
|
{
|
|
|
|
return saveImageToJPG(filename);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-12-31 12:12:40 +08:00
|
|
|
CCLOG("cocos2d: Image: saveToFile no support file extension(only .png or .jpg) for file: %s", filename.data());
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool Image::saveImageToPNG(std::string_view filePath, bool isToRGB)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
#if AX_USE_PNG
|
2019-11-23 20:27:39 +08:00
|
|
|
bool ret = false;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
png_structp png_ptr;
|
|
|
|
png_infop info_ptr;
|
2021-12-25 10:04:45 +08:00
|
|
|
png_bytep* row_pointers;
|
|
|
|
|
2021-05-05 19:49:30 +08:00
|
|
|
auto outStream = FileUtils::getInstance()->openFileStream(filePath, FileStream::Mode::WRITE);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_BREAK_IF(nullptr == outStream);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
|
|
|
|
|
|
|
|
if (nullptr == png_ptr)
|
|
|
|
{
|
2021-05-05 19:49:30 +08:00
|
|
|
outStream.reset();
|
2019-11-23 20:27:39 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
info_ptr = png_create_info_struct(png_ptr);
|
|
|
|
if (nullptr == info_ptr)
|
|
|
|
{
|
2021-05-05 19:49:30 +08:00
|
|
|
outStream.reset();
|
2019-11-23 20:27:39 +08:00
|
|
|
png_destroy_write_struct(&png_ptr, nullptr);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (setjmp(png_jmpbuf(png_ptr)))
|
|
|
|
{
|
2021-05-05 19:49:30 +08:00
|
|
|
outStream.reset();
|
2019-11-23 20:27:39 +08:00
|
|
|
png_destroy_write_struct(&png_ptr, &info_ptr);
|
|
|
|
break;
|
|
|
|
}
|
2021-04-22 19:49:43 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
// png_init_io(png_ptr, outStream);
|
2021-05-05 19:49:30 +08:00
|
|
|
png_set_write_fn(png_ptr, outStream.get(), pngWriteCallback, nullptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (!isToRGB && hasAlpha())
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
png_set_IHDR(png_ptr, info_ptr, _width, _height, 8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
|
|
|
|
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
else
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
png_set_IHDR(png_ptr, info_ptr, _width, _height, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
|
|
|
|
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
png_write_info(png_ptr, info_ptr);
|
|
|
|
|
|
|
|
png_set_packing(png_ptr);
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
row_pointers = (png_bytep*)malloc(_height * sizeof(png_bytep));
|
|
|
|
if (row_pointers == nullptr)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-05-05 19:49:30 +08:00
|
|
|
outStream.reset();
|
2019-11-23 20:27:39 +08:00
|
|
|
png_destroy_write_struct(&png_ptr, &info_ptr);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!hasAlpha())
|
|
|
|
{
|
|
|
|
for (int i = 0; i < (int)_height; i++)
|
|
|
|
{
|
|
|
|
row_pointers[i] = (png_bytep)_data + i * _width * 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
png_write_image(png_ptr, row_pointers);
|
|
|
|
|
|
|
|
free(row_pointers);
|
|
|
|
row_pointers = nullptr;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (isToRGB)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
uint8_t* tempData = static_cast<uint8_t*>(malloc(_width * _height * 3));
|
2019-11-23 20:27:39 +08:00
|
|
|
if (nullptr == tempData)
|
|
|
|
{
|
2021-05-05 19:49:30 +08:00
|
|
|
outStream.reset();
|
2019-11-23 20:27:39 +08:00
|
|
|
png_destroy_write_struct(&png_ptr, &info_ptr);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
free(row_pointers);
|
|
|
|
row_pointers = nullptr;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < _height; ++i)
|
|
|
|
{
|
|
|
|
for (int j = 0; j < _width; ++j)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
tempData[(i * _width + j) * 3] = _data[(i * _width + j) * 4];
|
2019-11-23 20:27:39 +08:00
|
|
|
tempData[(i * _width + j) * 3 + 1] = _data[(i * _width + j) * 4 + 1];
|
|
|
|
tempData[(i * _width + j) * 3 + 2] = _data[(i * _width + j) * 4 + 2];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < (int)_height; i++)
|
|
|
|
{
|
|
|
|
row_pointers[i] = (png_bytep)tempData + i * _width * 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
png_write_image(png_ptr, row_pointers);
|
|
|
|
|
|
|
|
free(row_pointers);
|
|
|
|
row_pointers = nullptr;
|
|
|
|
|
|
|
|
if (tempData != nullptr)
|
|
|
|
{
|
|
|
|
free(tempData);
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
for (int i = 0; i < (int)_height; i++)
|
|
|
|
{
|
|
|
|
row_pointers[i] = (png_bytep)_data + i * _width * 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
png_write_image(png_ptr, row_pointers);
|
|
|
|
|
|
|
|
free(row_pointers);
|
|
|
|
row_pointers = nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
png_write_end(png_ptr, info_ptr);
|
|
|
|
|
|
|
|
png_destroy_write_struct(&png_ptr, &info_ptr);
|
|
|
|
|
2021-05-05 19:49:30 +08:00
|
|
|
outStream.reset();
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
ret = true;
|
|
|
|
} while (0);
|
|
|
|
return ret;
|
|
|
|
#else
|
|
|
|
CCLOG("png is not enabled, please enable it in ccConfig.h");
|
|
|
|
return false;
|
2022-07-15 19:17:01 +08:00
|
|
|
#endif // AX_USE_PNG
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool Image::saveImageToJPG(std::string_view filePath)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
#if AX_USE_JPEG
|
2019-11-23 20:27:39 +08:00
|
|
|
bool ret = false;
|
2021-12-25 10:04:45 +08:00
|
|
|
do
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
struct jpeg_compress_struct cinfo;
|
|
|
|
struct jpeg_error_mgr jerr;
|
2021-12-25 10:04:45 +08:00
|
|
|
std::unique_ptr<FileStream> outfile; /* target file */
|
|
|
|
JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */
|
|
|
|
int row_stride; /* physical row width in image buffer */
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
cinfo.err = jpeg_std_error(&jerr);
|
|
|
|
/* Now we can initialize the JPEG compression object. */
|
|
|
|
jpeg_create_compress(&cinfo);
|
|
|
|
|
2021-04-22 19:49:43 +08:00
|
|
|
outfile = FileUtils::getInstance()->openFileStream(filePath, FileStream::Mode::WRITE);
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_BREAK_IF(nullptr == outfile);
|
2021-04-22 19:49:43 +08:00
|
|
|
|
|
|
|
unsigned char* outputBuffer = nullptr;
|
2021-12-25 10:04:45 +08:00
|
|
|
unsigned long outputSize = 0;
|
2021-04-22 19:49:43 +08:00
|
|
|
jpeg_mem_dest(&cinfo, &outputBuffer, &outputSize);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
cinfo.image_width = _width; /* image width and height, in pixels */
|
|
|
|
cinfo.image_height = _height;
|
2019-11-23 20:27:39 +08:00
|
|
|
cinfo.input_components = 3; /* # of color components per pixel */
|
2021-12-25 10:04:45 +08:00
|
|
|
cinfo.in_color_space = JCS_RGB; /* colorspace of input image */
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
jpeg_set_defaults(&cinfo);
|
|
|
|
jpeg_set_quality(&cinfo, 90, TRUE);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
jpeg_start_compress(&cinfo, TRUE);
|
|
|
|
|
|
|
|
row_stride = _width * 3; /* JSAMPLEs per row in image_buffer */
|
|
|
|
|
|
|
|
if (hasAlpha())
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
uint8_t* tempData = static_cast<uint8_t*>(malloc(_width * _height * 3));
|
2019-11-23 20:27:39 +08:00
|
|
|
if (nullptr == tempData)
|
|
|
|
{
|
|
|
|
jpeg_finish_compress(&cinfo);
|
|
|
|
jpeg_destroy_compress(&cinfo);
|
2021-04-22 19:49:43 +08:00
|
|
|
|
2021-05-05 19:49:30 +08:00
|
|
|
outfile.reset();
|
2021-04-22 19:49:43 +08:00
|
|
|
if (outputBuffer)
|
|
|
|
{
|
|
|
|
free(outputBuffer);
|
|
|
|
outputBuffer = nullptr;
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < _height; ++i)
|
|
|
|
{
|
|
|
|
for (int j = 0; j < _width; ++j)
|
|
|
|
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
tempData[(i * _width + j) * 3] = _data[(i * _width + j) * 4];
|
2019-11-23 20:27:39 +08:00
|
|
|
tempData[(i * _width + j) * 3 + 1] = _data[(i * _width + j) * 4 + 1];
|
|
|
|
tempData[(i * _width + j) * 3 + 2] = _data[(i * _width + j) * 4 + 2];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while (cinfo.next_scanline < cinfo.image_height)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
row_pointer[0] = &tempData[cinfo.next_scanline * row_stride];
|
|
|
|
(void)jpeg_write_scanlines(&cinfo, row_pointer, 1);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (tempData != nullptr)
|
|
|
|
{
|
|
|
|
free(tempData);
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
else
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
while (cinfo.next_scanline < cinfo.image_height)
|
|
|
|
{
|
|
|
|
row_pointer[0] = &_data[cinfo.next_scanline * row_stride];
|
|
|
|
(void)jpeg_write_scanlines(&cinfo, row_pointer, 1);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
jpeg_finish_compress(&cinfo);
|
2021-04-22 19:49:43 +08:00
|
|
|
|
|
|
|
outfile->write(outputBuffer, outputSize);
|
2021-05-05 19:49:30 +08:00
|
|
|
outfile.reset();
|
|
|
|
|
2021-04-22 19:49:43 +08:00
|
|
|
if (outputBuffer)
|
|
|
|
{
|
|
|
|
free(outputBuffer);
|
|
|
|
outputBuffer = nullptr;
|
|
|
|
}
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
jpeg_destroy_compress(&cinfo);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
ret = true;
|
|
|
|
} while (0);
|
|
|
|
return ret;
|
|
|
|
#else
|
|
|
|
CCLOG("jpeg is not enabled, please enable it in ccConfig.h");
|
|
|
|
return false;
|
2022-07-15 19:17:01 +08:00
|
|
|
#endif // AX_USE_JPEG
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Image::premultiplyAlpha()
|
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
#if AX_ENABLE_PREMULTIPLIED_ALPHA
|
2020-09-25 11:07:56 +08:00
|
|
|
CCASSERT(_pixelFormat == backend::PixelFormat::RGBA8, "The pixel format should be RGBA8888!");
|
2020-11-16 12:21:27 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
unsigned int* fourBytes = (unsigned int*)_data;
|
2020-11-16 12:21:27 +08:00
|
|
|
for (int i = 0; i < _width * _height; i++)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
uint8_t* p = _data + i * 4;
|
2022-07-15 19:17:01 +08:00
|
|
|
fourBytes[i] = AX_RGB_PREMULTIPLY_ALPHA(p[0], p[1], p[2], p[3]);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2020-11-16 12:21:27 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
_hasPremultipliedAlpha = true;
|
2020-11-16 12:21:27 +08:00
|
|
|
#else
|
|
|
|
_hasPremultipliedAlpha = false;
|
2019-11-23 20:27:39 +08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
static inline uint8_t clamp(int x)
|
|
|
|
{
|
2020-09-01 14:57:18 +08:00
|
|
|
return (uint8_t)(x >= 0 ? (x < 255 ? x : 255) : 0);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Image::reversePremultipliedAlpha()
|
|
|
|
{
|
2020-09-25 11:07:56 +08:00
|
|
|
CCASSERT(_pixelFormat == backend::PixelFormat::RGBA8, "The pixel format should be RGBA8888!");
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
unsigned int* fourBytes = (unsigned int*)_data;
|
|
|
|
for (int i = 0; i < _width * _height; i++)
|
|
|
|
{
|
2020-09-01 14:57:18 +08:00
|
|
|
uint8_t* p = _data + i * 4;
|
2019-11-23 20:27:39 +08:00
|
|
|
if (p[3] > 0)
|
|
|
|
{
|
|
|
|
fourBytes[i] = clamp(int(std::ceil((p[0] * 255.0f) / p[3]))) |
|
2021-12-25 10:04:45 +08:00
|
|
|
clamp(int(std::ceil((p[1] * 255.0f) / p[3]))) << 8 |
|
|
|
|
clamp(int(std::ceil((p[2] * 255.0f) / p[3]))) << 16 | p[3] << 24;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
_hasPremultipliedAlpha = false;
|
|
|
|
}
|
|
|
|
|
2022-07-11 17:50:21 +08:00
|
|
|
NS_AX_END
|