mirror of
https://github.com/GRRLIB/GRRLIB.git
synced 2024-09-19 20:35:05 +00:00
Don't use custom int types in pngu
This commit is contained in:
Crayon2000
parent
bb8d8ed569
commit
4b65d83fea
2 changed files with 161 additions and 163 deletions
|
|
@ -19,13 +19,13 @@ More info : http://frontier-dev.net
|
|||
#define PNGU_SOURCE_DEVICE 2
|
||||
|
||||
#define _SHIFTL(v, s, w) \
|
||||
((PNGU_u32) (((PNGU_u32)(v) & ((0x01 << (w)) - 1)) << (s)))
|
||||
((uint32_t) (((uint32_t)(v) & ((0x01 << (w)) - 1)) << (s)))
|
||||
#define _SHIFTR(v, s, w) \
|
||||
((PNGU_u32)(((PNGU_u32)(v) >> (s)) & ((0x01 << (w)) - 1)))
|
||||
((uint32_t)(((uint32_t)(v) >> (s)) & ((0x01 << (w)) - 1)))
|
||||
|
||||
// Prototypes of helper functions
|
||||
int pngu_info (IMGCTX ctx);
|
||||
int pngu_decode (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, PNGU_u32 stripAlpha);
|
||||
int pngu_decode (IMGCTX ctx, uint32_t width, uint32_t height, uint32_t stripAlpha);
|
||||
void pngu_free_info (IMGCTX ctx);
|
||||
void pngu_read_data_from_buffer (png_structp png_ptr, png_bytep data, png_size_t length);
|
||||
void pngu_write_data_to_buffer (png_structp png_ptr, png_bytep data, png_size_t length);
|
||||
|
|
@ -39,12 +39,12 @@ struct _IMGCTX
|
|||
int source;
|
||||
void *buffer;
|
||||
char *filename;
|
||||
PNGU_u32 cursor;
|
||||
uint32_t cursor;
|
||||
|
||||
PNGU_u32 propRead;
|
||||
uint32_t propRead;
|
||||
PNGUPROP prop;
|
||||
|
||||
PNGU_u32 infoRead;
|
||||
uint32_t infoRead;
|
||||
png_structp png_ptr;
|
||||
png_infop info_ptr;
|
||||
FILE *fd;
|
||||
|
|
@ -136,7 +136,7 @@ int PNGU_GetImageProperties (IMGCTX ctx, PNGUPROP *imgprop)
|
|||
}
|
||||
|
||||
|
||||
int PNGU_DecodeToYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride)
|
||||
int PNGU_DecodeToYCbYCr (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer, uint32_t stride)
|
||||
{
|
||||
// width needs to be divisible by two
|
||||
if (width % 2)
|
||||
|
|
@ -151,12 +151,12 @@ int PNGU_DecodeToYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buff
|
|||
return result;
|
||||
|
||||
// Copy image to the output buffer
|
||||
const PNGU_u32 buffWidth = (width + stride) / 2;
|
||||
for (PNGU_u32 y = 0; y < height; y++)
|
||||
const uint32_t buffWidth = (width + stride) / 2;
|
||||
for (uint32_t y = 0; y < height; y++)
|
||||
{
|
||||
for (PNGU_u32 x = 0; x < (width / 2); x++)
|
||||
for (uint32_t x = 0; x < (width / 2); x++)
|
||||
{
|
||||
((PNGU_u32 *)buffer)[y*buffWidth+x] = PNGU_RGB8_TO_YCbYCr (*(ctx->row_pointers[y]+x*6), *(ctx->row_pointers[y]+x*6+1), *(ctx->row_pointers[y]+x*6+2),
|
||||
((uint32_t *)buffer)[y*buffWidth+x] = PNGU_RGB8_TO_YCbYCr (*(ctx->row_pointers[y]+x*6), *(ctx->row_pointers[y]+x*6+1), *(ctx->row_pointers[y]+x*6+2),
|
||||
*(ctx->row_pointers[y]+x*6+3), *(ctx->row_pointers[y]+x*6+4), *(ctx->row_pointers[y]+x*6+5));
|
||||
}
|
||||
}
|
||||
|
|
@ -170,23 +170,23 @@ int PNGU_DecodeToYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buff
|
|||
}
|
||||
|
||||
|
||||
int PNGU_DecodeToRGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride)
|
||||
int PNGU_DecodeToRGB565 (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer, uint32_t stride)
|
||||
{
|
||||
const int result = pngu_decode (ctx, width, height, 1);
|
||||
if (result != PNGU_OK)
|
||||
return result;
|
||||
|
||||
const PNGU_u32 buffWidth = width + stride;
|
||||
const uint32_t buffWidth = width + stride;
|
||||
|
||||
// Copy image to the output buffer
|
||||
for (PNGU_u32 y = 0; y < height; y++)
|
||||
for (uint32_t y = 0; y < height; y++)
|
||||
{
|
||||
for (PNGU_u32 x = 0; x < width; x++)
|
||||
for (uint32_t x = 0; x < width; x++)
|
||||
{
|
||||
((PNGU_u16 *)buffer)[y*buffWidth+x] =
|
||||
(((PNGU_u16) (ctx->row_pointers[y][x*3] & 0xF8)) << 8) |
|
||||
(((PNGU_u16) (ctx->row_pointers[y][x*3+1] & 0xFC)) << 3) |
|
||||
(((PNGU_u16) (ctx->row_pointers[y][x*3+2] & 0xF8)) >> 3);
|
||||
((uint16_t *)buffer)[y*buffWidth+x] =
|
||||
(((uint16_t) (ctx->row_pointers[y][x*3] & 0xF8)) << 8) |
|
||||
(((uint16_t) (ctx->row_pointers[y][x*3+1] & 0xFC)) << 3) |
|
||||
(((uint16_t) (ctx->row_pointers[y][x*3+2] & 0xF8)) >> 3);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -199,19 +199,19 @@ int PNGU_DecodeToRGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buff
|
|||
}
|
||||
|
||||
|
||||
int PNGU_DecodeToRGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride, PNGU_u8 default_alpha)
|
||||
int PNGU_DecodeToRGBA8 (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer, uint32_t stride, uint8_t default_alpha)
|
||||
{
|
||||
const int result = pngu_decode (ctx, width, height, 0);
|
||||
if (result != PNGU_OK)
|
||||
return result;
|
||||
|
||||
const PNGU_u32 buffWidth = width + stride;
|
||||
const uint32_t buffWidth = width + stride;
|
||||
|
||||
// Check is source image has an alpha channel
|
||||
if ( (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB_ALPHA) )
|
||||
{
|
||||
// Alpha channel present, copy image to the output buffer
|
||||
for (PNGU_u32 y = 0; y < height; y++)
|
||||
for (uint32_t y = 0; y < height; y++)
|
||||
{
|
||||
memcpy (buffer + (y * buffWidth * 4), ctx->row_pointers[y], width * 4);
|
||||
}
|
||||
|
|
@ -219,15 +219,15 @@ int PNGU_DecodeToRGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffe
|
|||
else
|
||||
{
|
||||
// No alpha channel present, copy image to the output buffer
|
||||
for (PNGU_u32 y = 0; y < height; y++)
|
||||
for (uint32_t y = 0; y < height; y++)
|
||||
{
|
||||
for (PNGU_u32 x = 0; x < width; x++)
|
||||
for (uint32_t x = 0; x < width; x++)
|
||||
{
|
||||
((PNGU_u32 *)buffer)[y*buffWidth+x] =
|
||||
(((PNGU_u32) ctx->row_pointers[y][x*3]) << 24) |
|
||||
(((PNGU_u32) ctx->row_pointers[y][x*3+1]) << 16) |
|
||||
(((PNGU_u32) ctx->row_pointers[y][x*3+2]) << 8) |
|
||||
((PNGU_u32) default_alpha);
|
||||
((uint32_t *)buffer)[y*buffWidth+x] =
|
||||
(((uint32_t) ctx->row_pointers[y][x*3]) << 24) |
|
||||
(((uint32_t) ctx->row_pointers[y][x*3+1]) << 16) |
|
||||
(((uint32_t) ctx->row_pointers[y][x*3+2]) << 8) |
|
||||
((uint32_t) default_alpha);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -241,7 +241,7 @@ int PNGU_DecodeToRGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffe
|
|||
}
|
||||
|
||||
|
||||
int PNGU_DecodeTo4x4RGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer)
|
||||
int PNGU_DecodeTo4x4RGB565 (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer)
|
||||
{
|
||||
// width and height need to be divisible by four
|
||||
if ((width % 4) || (height % 4))
|
||||
|
|
@ -252,42 +252,42 @@ int PNGU_DecodeTo4x4RGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *b
|
|||
return result;
|
||||
|
||||
// Copy image to the output buffer
|
||||
const PNGU_u32 qwidth = width / 4;
|
||||
const PNGU_u32 qheight = height / 4;
|
||||
const uint32_t qwidth = width / 4;
|
||||
const uint32_t qheight = height / 4;
|
||||
|
||||
for (PNGU_u32 y = 0; y < qheight; y++)
|
||||
for (uint32_t y = 0; y < qheight; y++)
|
||||
{
|
||||
for (PNGU_u32 x = 0; x < qwidth; x++)
|
||||
for (uint32_t x = 0; x < qwidth; x++)
|
||||
{
|
||||
const int blockbase = (y * qwidth + x) * 4;
|
||||
|
||||
PNGU_u64 field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*12));
|
||||
PNGU_u64 field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4]+x*12+8));
|
||||
((PNGU_u64 *) buffer)[blockbase] =
|
||||
uint64_t field64 = *((uint64_t *)(ctx->row_pointers[y*4]+x*12));
|
||||
uint64_t field32 = (uint64_t) *((uint32_t *)(ctx->row_pointers[y*4]+x*12+8));
|
||||
((uint64_t *) buffer)[blockbase] =
|
||||
(((field64 & 0xF800000000000000ULL) | ((field64 & 0xFC000000000000ULL) << 3) | ((field64 & 0xF80000000000ULL) << 5)) |
|
||||
(((field64 & 0xF800000000ULL) << 8) | ((field64 & 0xFC000000ULL) << 11) | ((field64 & 0xF80000ULL) << 13)) |
|
||||
(((field64 & 0xF800ULL) << 16) | ((field64 & 0xFCULL) << 19) | ((field32 & 0xF8000000ULL) >> 11)) |
|
||||
(((field32 & 0xF80000ULL) >> 8) | ((field32 & 0xFC00ULL) >> 5) | ((field32 & 0xF8ULL) >> 3)));
|
||||
|
||||
field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*12));
|
||||
field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+1]+x*12+8));
|
||||
((PNGU_u64 *) buffer)[blockbase+1] =
|
||||
field64 = *((uint64_t *)(ctx->row_pointers[y*4+1]+x*12));
|
||||
field32 = (uint64_t) *((uint32_t *)(ctx->row_pointers[y*4+1]+x*12+8));
|
||||
((uint64_t *) buffer)[blockbase+1] =
|
||||
(((field64 & 0xF800000000000000ULL) | ((field64 & 0xFC000000000000ULL) << 3) | ((field64 & 0xF80000000000ULL) << 5)) |
|
||||
(((field64 & 0xF800000000ULL) << 8) | ((field64 & 0xFC000000ULL) << 11) | ((field64 & 0xF80000ULL) << 13)) |
|
||||
(((field64 & 0xF800ULL) << 16) | ((field64 & 0xFCULL) << 19) | ((field32 & 0xF8000000ULL) >> 11)) |
|
||||
(((field32 & 0xF80000ULL) >> 8) | ((field32 & 0xFC00ULL) >> 5) | ((field32 & 0xF8ULL) >> 3)));
|
||||
|
||||
field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*12));
|
||||
field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+2]+x*12+8));
|
||||
((PNGU_u64 *) buffer)[blockbase+2] =
|
||||
field64 = *((uint64_t *)(ctx->row_pointers[y*4+2]+x*12));
|
||||
field32 = (uint64_t) *((uint32_t *)(ctx->row_pointers[y*4+2]+x*12+8));
|
||||
((uint64_t *) buffer)[blockbase+2] =
|
||||
(((field64 & 0xF800000000000000ULL) | ((field64 & 0xFC000000000000ULL) << 3) | ((field64 & 0xF80000000000ULL) << 5)) |
|
||||
(((field64 & 0xF800000000ULL) << 8) | ((field64 & 0xFC000000ULL) << 11) | ((field64 & 0xF80000ULL) << 13)) |
|
||||
(((field64 & 0xF800ULL) << 16) | ((field64 & 0xFCULL) << 19) | ((field32 & 0xF8000000ULL) >> 11)) |
|
||||
(((field32 & 0xF80000ULL) >> 8) | ((field32 & 0xFC00ULL) >> 5) | ((field32 & 0xF8ULL) >> 3)));
|
||||
|
||||
field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*12));
|
||||
field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+3]+x*12+8));
|
||||
((PNGU_u64 *) buffer)[blockbase+3] =
|
||||
field64 = *((uint64_t *)(ctx->row_pointers[y*4+3]+x*12));
|
||||
field32 = (uint64_t) *((uint32_t *)(ctx->row_pointers[y*4+3]+x*12+8));
|
||||
((uint64_t *) buffer)[blockbase+3] =
|
||||
(((field64 & 0xF800000000000000ULL) | ((field64 & 0xFC000000000000ULL) << 3) | ((field64 & 0xF80000000000ULL) << 5)) |
|
||||
(((field64 & 0xF800000000ULL) << 8) | ((field64 & 0xFC000000ULL) << 11) | ((field64 & 0xF80000ULL) << 13)) |
|
||||
(((field64 & 0xF800ULL) << 16) | ((field64 & 0xFCULL) << 19) | ((field32 & 0xF8000000ULL) >> 11)) |
|
||||
|
|
@ -304,7 +304,7 @@ int PNGU_DecodeTo4x4RGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *b
|
|||
}
|
||||
|
||||
|
||||
int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u8 default_alpha)
|
||||
int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer, uint8_t default_alpha)
|
||||
{
|
||||
// width and height need to be divisible by four
|
||||
if ((width % 4) || (height % 4))
|
||||
|
|
@ -315,22 +315,22 @@ int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *b
|
|||
return result;
|
||||
|
||||
// Init some vars
|
||||
const PNGU_u32 qwidth = width / 4;
|
||||
const PNGU_u32 qheight = height / 4;
|
||||
const uint32_t qwidth = width / 4;
|
||||
const uint32_t qheight = height / 4;
|
||||
|
||||
// Check is source image has an alpha channel
|
||||
if ( (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB_ALPHA) )
|
||||
{
|
||||
// Alpha channel present, copy image to the output buffer
|
||||
for (PNGU_u32 y = 0; y < qheight; y++)
|
||||
for (uint32_t y = 0; y < qheight; y++)
|
||||
{
|
||||
for (PNGU_u32 x = 0; x < qwidth; x++)
|
||||
for (uint32_t x = 0; x < qwidth; x++)
|
||||
{
|
||||
int blockbase = (y * qwidth + x) * 4;
|
||||
PNGU_u64 tmp;
|
||||
uint64_t tmp;
|
||||
|
||||
PNGU_u64 fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*16));
|
||||
PNGU_u64 fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*16+8));
|
||||
uint64_t fieldA = *((uint64_t *)(ctx->row_pointers[y*4]+x*16));
|
||||
uint64_t fieldB = *((uint64_t *)(ctx->row_pointers[y*4]+x*16+8));
|
||||
// If first pixel is opaque set MSB to 1 and encode colors in RGB555, else set MSB to 0 and encode colors in ARGB3444
|
||||
if ((fieldA & 0xE000000000ULL) == 0xE000000000ULL)
|
||||
tmp = 0x8000000000000000ULL | ((fieldA & 0xF800000000000000ULL) >> 1) | ((fieldA & 0xF8000000000000ULL) << 2) | ((fieldA & 0xF80000000000ULL) << 5);
|
||||
|
|
@ -354,10 +354,10 @@ int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *b
|
|||
tmp = tmp | 0x8000ULL | ((fieldB & 0xF8000000ULL) >> 17) | ((fieldB & 0xF80000ULL) >> 14) | ((fieldB & 0xF800ULL) >> 11);
|
||||
else
|
||||
tmp = tmp | ((fieldB & 0xE0ULL) << 7) | ((fieldB & 0xF0000000ULL) >> 20) | ((fieldB & 0xF00000ULL) >> 16) | ((fieldB & 0xF000ULL) >> 12);
|
||||
((PNGU_u64 *) buffer)[blockbase] = tmp;
|
||||
((uint64_t *) buffer)[blockbase] = tmp;
|
||||
|
||||
fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*16));
|
||||
fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*16+8));
|
||||
fieldA = *((uint64_t *)(ctx->row_pointers[y*4+1]+x*16));
|
||||
fieldB = *((uint64_t *)(ctx->row_pointers[y*4+1]+x*16+8));
|
||||
if ((fieldA & 0xE000000000ULL) == 0xE000000000ULL)
|
||||
// Opaque pixel, so set MSB to 1 and encode colors in RGB555
|
||||
tmp = 0x8000000000000000ULL | ((fieldA & 0xF800000000000000ULL) >> 1) | ((fieldA & 0xF8000000000000ULL) << 2) | ((fieldA & 0xF80000000000ULL) << 5);
|
||||
|
|
@ -385,10 +385,10 @@ int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *b
|
|||
else
|
||||
// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
|
||||
tmp = tmp | ((fieldB & 0xE0ULL) << 7) | ((fieldB & 0xF0000000ULL) >> 20) | ((fieldB & 0xF00000ULL) >> 16) | ((fieldB & 0xF000ULL) >> 12);
|
||||
((PNGU_u64 *) buffer)[blockbase+1] = tmp;
|
||||
((uint64_t *) buffer)[blockbase+1] = tmp;
|
||||
|
||||
fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*16));
|
||||
fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*16+8));
|
||||
fieldA = *((uint64_t *)(ctx->row_pointers[y*4+2]+x*16));
|
||||
fieldB = *((uint64_t *)(ctx->row_pointers[y*4+2]+x*16+8));
|
||||
if ((fieldA & 0xE000000000ULL) == 0xE000000000ULL)
|
||||
// Opaque pixel, so set MSB to 1 and encode colors in RGB555
|
||||
tmp = 0x8000000000000000ULL | ((fieldA & 0xF800000000000000ULL) >> 1) | ((fieldA & 0xF8000000000000ULL) << 2) | ((fieldA & 0xF80000000000ULL) << 5);
|
||||
|
|
@ -416,10 +416,10 @@ int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *b
|
|||
else
|
||||
// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
|
||||
tmp = tmp | ((fieldB & 0xE0ULL) << 7) | ((fieldB & 0xF0000000ULL) >> 20) | ((fieldB & 0xF00000ULL) >> 16) | ((fieldB & 0xF000ULL) >> 12);
|
||||
((PNGU_u64 *) buffer)[blockbase+2] = tmp;
|
||||
((uint64_t *) buffer)[blockbase+2] = tmp;
|
||||
|
||||
fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*16));
|
||||
fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*16+8));
|
||||
fieldA = *((uint64_t *)(ctx->row_pointers[y*4+3]+x*16));
|
||||
fieldB = *((uint64_t *)(ctx->row_pointers[y*4+3]+x*16+8));
|
||||
if ((fieldA & 0xE000000000ULL) == 0xE000000000ULL)
|
||||
// Opaque pixel, so set MSB to 1 and encode colors in RGB555
|
||||
tmp = 0x8000000000000000ULL | ((fieldA & 0xF800000000000000ULL) >> 1) | ((fieldA & 0xF8000000000000ULL) << 2) | ((fieldA & 0xF80000000000ULL) << 5);
|
||||
|
|
@ -447,13 +447,13 @@ int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *b
|
|||
else
|
||||
// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
|
||||
tmp = tmp | ((fieldB & 0xE0ULL) << 7) | ((fieldB & 0xF0000000ULL) >> 20) | ((fieldB & 0xF00000ULL) >> 16) | ((fieldB & 0xF000ULL) >> 12);
|
||||
((PNGU_u64 *) buffer)[blockbase+3] = tmp;
|
||||
((uint64_t *) buffer)[blockbase+3] = tmp;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
PNGU_u64 alphaMask;
|
||||
uint64_t alphaMask;
|
||||
|
||||
// No alpha channel present, copy image to the output buffer
|
||||
default_alpha = (default_alpha >> 5);
|
||||
|
|
@ -462,39 +462,39 @@ int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *b
|
|||
// The user wants an opaque texture, so set MSB to 1 and encode colors in RGB555
|
||||
alphaMask = 0x8000800080008000ULL;
|
||||
|
||||
for (PNGU_u32 y = 0; y < qheight; y++)
|
||||
for (uint32_t y = 0; y < qheight; y++)
|
||||
{
|
||||
for (PNGU_u32 x = 0; x < qwidth; x++)
|
||||
for (uint32_t x = 0; x < qwidth; x++)
|
||||
{
|
||||
int blockbase = (y * qwidth + x) * 4;
|
||||
|
||||
PNGU_u64 field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*12));
|
||||
PNGU_u64 field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4]+x*12+8));
|
||||
((PNGU_u64 *) buffer)[blockbase] =
|
||||
uint64_t field64 = *((uint64_t *)(ctx->row_pointers[y*4]+x*12));
|
||||
uint64_t field32 = (uint64_t) *((uint32_t *)(ctx->row_pointers[y*4]+x*12+8));
|
||||
((uint64_t *) buffer)[blockbase] =
|
||||
alphaMask | ((field64 & 0xF800000000000000ULL) >> 1) | ((field64 & 0xF8000000000000ULL) << 2) |
|
||||
((field64 & 0xF80000000000ULL) << 5) | ((field64 & 0xF800000000ULL) << 7) | ((field64 & 0xF8000000ULL) << 10) |
|
||||
((field64 & 0xF80000ULL) << 13) | ((field64 & 0xF800ULL) << 15) | ((field64 & 0xF8ULL) << 18) |
|
||||
((field32 & 0xF8000000ULL) >> 11) | ((field32 & 0xF80000ULL) >> 9) | ((field32 & 0xF800ULL) >> 6) | ((field32 & 0xF8ULL) >> 3);
|
||||
|
||||
field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*12));
|
||||
field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+1]+x*12+8));
|
||||
((PNGU_u64 *) buffer)[blockbase+1] =
|
||||
field64 = *((uint64_t *)(ctx->row_pointers[y*4+1]+x*12));
|
||||
field32 = (uint64_t) *((uint32_t *)(ctx->row_pointers[y*4+1]+x*12+8));
|
||||
((uint64_t *) buffer)[blockbase+1] =
|
||||
alphaMask | ((field64 & 0xF800000000000000ULL) >> 1) | ((field64 & 0xF8000000000000ULL) << 2) |
|
||||
((field64 & 0xF80000000000ULL) << 5) | ((field64 & 0xF800000000ULL) << 7) | ((field64 & 0xF8000000ULL) << 10) |
|
||||
((field64 & 0xF80000ULL) << 13) | ((field64 & 0xF800ULL) << 15) | ((field64 & 0xF8ULL) << 18) |
|
||||
((field32 & 0xF8000000ULL) >> 11) | ((field32 & 0xF80000ULL) >> 9) | ((field32 & 0xF800ULL) >> 6) | ((field32 & 0xF8ULL) >> 3);
|
||||
|
||||
field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*12));
|
||||
field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+2]+x*12+8));
|
||||
((PNGU_u64 *) buffer)[blockbase+2] =
|
||||
field64 = *((uint64_t *)(ctx->row_pointers[y*4+2]+x*12));
|
||||
field32 = (uint64_t) *((uint32_t *)(ctx->row_pointers[y*4+2]+x*12+8));
|
||||
((uint64_t *) buffer)[blockbase+2] =
|
||||
alphaMask | ((field64 & 0xF800000000000000ULL) >> 1) | ((field64 & 0xF8000000000000ULL) << 2) |
|
||||
((field64 & 0xF80000000000ULL) << 5) | ((field64 & 0xF800000000ULL) << 7) | ((field64 & 0xF8000000ULL) << 10) |
|
||||
((field64 & 0xF80000ULL) << 13) | ((field64 & 0xF800ULL) << 15) | ((field64 & 0xF8ULL) << 18) |
|
||||
((field32 & 0xF8000000ULL) >> 11) | ((field32 & 0xF80000ULL) >> 9) | ((field32 & 0xF800ULL) >> 6) | ((field32 & 0xF8ULL) >> 3);
|
||||
|
||||
field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*12));
|
||||
field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+3]+x*12+8));
|
||||
((PNGU_u64 *) buffer)[blockbase+3] =
|
||||
field64 = *((uint64_t *)(ctx->row_pointers[y*4+3]+x*12));
|
||||
field32 = (uint64_t) *((uint32_t *)(ctx->row_pointers[y*4+3]+x*12+8));
|
||||
((uint64_t *) buffer)[blockbase+3] =
|
||||
alphaMask | ((field64 & 0xF800000000000000ULL) >> 1) | ((field64 & 0xF8000000000000ULL) << 2) |
|
||||
((field64 & 0xF80000000000ULL) << 5) | ((field64 & 0xF800000000ULL) << 7) | ((field64 & 0xF8000000ULL) << 10) |
|
||||
((field64 & 0xF80000ULL) << 13) | ((field64 & 0xF800ULL) << 15) | ((field64 & 0xF8ULL) << 18) |
|
||||
|
|
@ -506,42 +506,42 @@ int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *b
|
|||
{
|
||||
// The user wants a translucid texture, so set MSB to 0 and encode colors in ARGB3444
|
||||
default_alpha = (default_alpha << 4);
|
||||
alphaMask = (((PNGU_u64) default_alpha) << 56) | (((PNGU_u64) default_alpha) << 40) |
|
||||
(((PNGU_u64) default_alpha) << 24) | (((PNGU_u64) default_alpha) << 8);
|
||||
alphaMask = (((uint64_t) default_alpha) << 56) | (((uint64_t) default_alpha) << 40) |
|
||||
(((uint64_t) default_alpha) << 24) | (((uint64_t) default_alpha) << 8);
|
||||
|
||||
for (PNGU_u32 y = 0; y < qheight; y++)
|
||||
for (uint32_t y = 0; y < qheight; y++)
|
||||
{
|
||||
for (PNGU_u32 x = 0; x < qwidth; x++)
|
||||
for (uint32_t x = 0; x < qwidth; x++)
|
||||
{
|
||||
int blockbase = (y * qwidth + x) * 4;
|
||||
|
||||
PNGU_u64 field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*12));
|
||||
PNGU_u64 field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4]+x*12+8));
|
||||
((PNGU_u64 *) buffer)[blockbase] =
|
||||
uint64_t field64 = *((uint64_t *)(ctx->row_pointers[y*4]+x*12));
|
||||
uint64_t field32 = (uint64_t) *((uint32_t *)(ctx->row_pointers[y*4]+x*12+8));
|
||||
((uint64_t *) buffer)[blockbase] =
|
||||
alphaMask | ((field64 & 0xF000000000000000ULL) >> 4) | (field64 & 0xF0000000000000ULL) | ((field64 & 0xF00000000000ULL) << 4) |
|
||||
((field64 & 0xF000000000ULL) << 4) | ((field64 & 0xF0000000ULL) << 8) | ((field64 & 0xF00000ULL) << 12) |
|
||||
((field64 & 0xF000ULL) << 12) | ((field64 & 0xF0ULL) << 16) | ((field32 & 0xF0000000ULL) >> 12) |
|
||||
((field32 & 0xF00000ULL) >> 12) | ((field32 & 0xF000ULL) >> 8) | ((field32 & 0xF0ULL) >> 4);
|
||||
|
||||
field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*12));
|
||||
field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+1]+x*12+8));
|
||||
((PNGU_u64 *) buffer)[blockbase+1] =
|
||||
field64 = *((uint64_t *)(ctx->row_pointers[y*4+1]+x*12));
|
||||
field32 = (uint64_t) *((uint32_t *)(ctx->row_pointers[y*4+1]+x*12+8));
|
||||
((uint64_t *) buffer)[blockbase+1] =
|
||||
alphaMask | ((field64 & 0xF000000000000000ULL) >> 4) | (field64 & 0xF0000000000000ULL) | ((field64 & 0xF00000000000ULL) << 4) |
|
||||
((field64 & 0xF000000000ULL) << 4) | ((field64 & 0xF0000000ULL) << 8) | ((field64 & 0xF00000ULL) << 12) |
|
||||
((field64 & 0xF000ULL) << 12) | ((field64 & 0xF0ULL) << 16) | ((field32 & 0xF0000000ULL) >> 12) |
|
||||
((field32 & 0xF00000ULL) >> 12) | ((field32 & 0xF000ULL) >> 8) | ((field32 & 0xF0ULL) >> 4);
|
||||
|
||||
field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*12));
|
||||
field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+2]+x*12+8));
|
||||
((PNGU_u64 *) buffer)[blockbase+2] =
|
||||
field64 = *((uint64_t *)(ctx->row_pointers[y*4+2]+x*12));
|
||||
field32 = (uint64_t) *((uint32_t *)(ctx->row_pointers[y*4+2]+x*12+8));
|
||||
((uint64_t *) buffer)[blockbase+2] =
|
||||
alphaMask | ((field64 & 0xF000000000000000ULL) >> 4) | (field64 & 0xF0000000000000ULL) | ((field64 & 0xF00000000000ULL) << 4) |
|
||||
((field64 & 0xF000000000ULL) << 4) | ((field64 & 0xF0000000ULL) << 8) | ((field64 & 0xF00000ULL) << 12) |
|
||||
((field64 & 0xF000ULL) << 12) | ((field64 & 0xF0ULL) << 16) | ((field32 & 0xF0000000ULL) >> 12) |
|
||||
((field32 & 0xF00000ULL) >> 12) | ((field32 & 0xF000ULL) >> 8) | ((field32 & 0xF0ULL) >> 4);
|
||||
|
||||
field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*12));
|
||||
field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+3]+x*12+8));
|
||||
((PNGU_u64 *) buffer)[blockbase+3] =
|
||||
field64 = *((uint64_t *)(ctx->row_pointers[y*4+3]+x*12));
|
||||
field32 = (uint64_t) *((uint32_t *)(ctx->row_pointers[y*4+3]+x*12+8));
|
||||
((uint64_t *) buffer)[blockbase+3] =
|
||||
alphaMask | ((field64 & 0xF000000000000000ULL) >> 4) | (field64 & 0xF0000000000000ULL) | ((field64 & 0xF00000000000ULL) << 4) |
|
||||
((field64 & 0xF000000000ULL) << 4) | ((field64 & 0xF0000000ULL) << 8) | ((field64 & 0xF00000ULL) << 12) |
|
||||
((field64 & 0xF000ULL) << 12) | ((field64 & 0xF0ULL) << 16) | ((field32 & 0xF0000000ULL) >> 12) |
|
||||
|
|
@ -560,15 +560,15 @@ int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *b
|
|||
}
|
||||
|
||||
// Coded by Tantric for WiiMC (http://www.wiimc.org)
|
||||
static inline PNGU_u32 coordsRGBA8(PNGU_u32 x, PNGU_u32 y, PNGU_u32 w)
|
||||
static inline uint32_t coordsRGBA8(uint32_t x, uint32_t y, uint32_t w)
|
||||
{
|
||||
return ((((y >> 2) * (w >> 2) + (x >> 2)) << 5) + ((y & 3) << 2) + (x & 3)) << 1;
|
||||
}
|
||||
|
||||
// Coded by Tantric for WiiMC (http://www.wiimc.org)
|
||||
PNGU_u8 * PNGU_DecodeTo4x4RGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, int * dstWidth, int * dstHeight)
|
||||
uint8_t * PNGU_DecodeTo4x4RGBA8 (IMGCTX ctx, uint32_t width, uint32_t height, int * dstWidth, int * dstHeight)
|
||||
{
|
||||
PNGU_u8 default_alpha = 255; // default alpha value, which is used if the source image doesn't have an alpha channel.
|
||||
uint8_t default_alpha = 255; // default alpha value, which is used if the source image doesn't have an alpha channel.
|
||||
int x, y, x2=0, y2=0;
|
||||
int xRatio = 0, yRatio = 0;
|
||||
|
||||
|
|
@ -598,13 +598,16 @@ PNGU_u8 * PNGU_DecodeTo4x4RGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, in
|
|||
|
||||
int padWidth = newWidth;
|
||||
int padHeight = newHeight;
|
||||
if(padWidth%4) padWidth += (4-padWidth%4);
|
||||
if(padHeight%4) padHeight += (4-padHeight%4);
|
||||
if(padWidth%4)
|
||||
padWidth += (4-padWidth%4);
|
||||
if(padHeight%4)
|
||||
padHeight += (4-padHeight%4);
|
||||
|
||||
int len = (padWidth * padHeight) << 2;
|
||||
if(len%32) len += (32-len%32);
|
||||
if(len%32)
|
||||
len += (32-len%32);
|
||||
|
||||
PNGU_u8 *dst = memalign (32, len);
|
||||
uint8_t *dst = memalign (32, len);
|
||||
|
||||
if(!dst)
|
||||
return NULL;
|
||||
|
|
@ -670,10 +673,10 @@ PNGU_u8 * PNGU_DecodeTo4x4RGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, in
|
|||
}
|
||||
|
||||
// Coded by Tantric for libwiigui (https://github.com/dborth/libwiigui)
|
||||
int PNGU_EncodeFromRGB (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride)
|
||||
int PNGU_EncodeFromRGB (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer, uint32_t stride)
|
||||
{
|
||||
png_uint_32 rowbytes;
|
||||
PNGU_u32 y;
|
||||
uint32_t y;
|
||||
|
||||
// Erase from the context any readed info
|
||||
pngu_free_info (ctx);
|
||||
|
|
@ -779,22 +782,22 @@ int PNGU_EncodeFromRGB (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffe
|
|||
}
|
||||
|
||||
// Coded by Tantric for libwiigui (https://github.com/dborth/libwiigui)
|
||||
int PNGU_EncodeFromGXTexture (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride)
|
||||
int PNGU_EncodeFromGXTexture (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer, uint32_t stride)
|
||||
{
|
||||
const unsigned char * ptr = (unsigned char*)buffer;
|
||||
unsigned char * tmpbuffer = (unsigned char *)malloc(width*height*3);
|
||||
memset(tmpbuffer, 0, width*height*3);
|
||||
|
||||
for(PNGU_u32 y=0; y < height; y++)
|
||||
for(uint32_t y=0; y < height; y++)
|
||||
{
|
||||
const PNGU_u32 tmpy1 = y * 640*3;
|
||||
const PNGU_u32 tmpy2 = y%4 << 2;
|
||||
const PNGU_u32 tmpyWid = (((y >> 2)<<4)*width);
|
||||
const uint32_t tmpy1 = y * 640*3;
|
||||
const uint32_t tmpy2 = y%4 << 2;
|
||||
const uint32_t tmpyWid = (((y >> 2)<<4)*width);
|
||||
|
||||
for(PNGU_u32 x=0; x < width; x++)
|
||||
for(uint32_t x=0; x < width; x++)
|
||||
{
|
||||
const png_uint_32 offset = tmpyWid + ((x >> 2)<<6) + ((tmpy2+ x%4 ) << 1);
|
||||
const PNGU_u32 tmpxy = x * 3 + tmpy1;
|
||||
const uint32_t tmpxy = x * 3 + tmpy1;
|
||||
|
||||
tmpbuffer[tmpxy ] = ptr[offset+1]; // R
|
||||
tmpbuffer[tmpxy+1] = ptr[offset+32]; // G
|
||||
|
|
@ -808,20 +811,20 @@ int PNGU_EncodeFromGXTexture (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void
|
|||
}
|
||||
|
||||
// Coded by Crayon for GRRLIB (https://github.com/GRRLIB/GRRLIB)
|
||||
int PNGU_EncodeFromEFB (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, PNGU_u32 stride)
|
||||
int PNGU_EncodeFromEFB (IMGCTX ctx, uint32_t width, uint32_t height, uint32_t stride)
|
||||
{
|
||||
unsigned char * tmpbuffer = (unsigned char *)malloc(width*height*3);
|
||||
memset(tmpbuffer, 0, width*height*3);
|
||||
|
||||
for(PNGU_u32 y=0; y < height; y++)
|
||||
for(uint32_t y=0; y < height; y++)
|
||||
{
|
||||
const PNGU_u32 tmpy = y * 640*3;
|
||||
for(PNGU_u32 x=0; x < width; x++)
|
||||
const uint32_t tmpy = y * 640*3;
|
||||
for(uint32_t x=0; x < width; x++)
|
||||
{
|
||||
PNGU_u32 regval = 0xc8000000|(_SHIFTL(x,2,10));
|
||||
uint32_t regval = 0xc8000000|(_SHIFTL(x,2,10));
|
||||
regval = (regval&~0x3FF000)|(_SHIFTL(y,12,10));
|
||||
const PNGU_u32 val = *(PNGU_u32*)regval;
|
||||
const PNGU_u32 tmpxy = x * 3 + tmpy;
|
||||
const uint32_t val = *(uint32_t*)regval;
|
||||
const uint32_t tmpxy = x * 3 + tmpy;
|
||||
tmpbuffer[tmpxy ] = _SHIFTR(val,16,8); // R
|
||||
tmpbuffer[tmpxy+1] = _SHIFTR(val,8,8); // G
|
||||
tmpbuffer[tmpxy+2] = val&0xff; // B
|
||||
|
|
@ -834,10 +837,10 @@ int PNGU_EncodeFromEFB (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, PNGU_u32 st
|
|||
}
|
||||
|
||||
|
||||
int PNGU_EncodeFromYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride)
|
||||
int PNGU_EncodeFromYCbYCr (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer, uint32_t stride)
|
||||
{
|
||||
png_uint_32 rowbytes;
|
||||
PNGU_u32 x, y, buffWidth;
|
||||
uint32_t x, y, buffWidth;
|
||||
|
||||
// Erase from the context any readed info
|
||||
pngu_free_info (ctx);
|
||||
|
|
@ -920,10 +923,10 @@ int PNGU_EncodeFromYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *bu
|
|||
ctx->row_pointers[y] = ctx->img_data + (y * rowbytes);
|
||||
|
||||
for (x = 0; x < (width / 2); x++)
|
||||
PNGU_YCbYCr_TO_RGB8 ( ((PNGU_u32 *)buffer)[y*buffWidth+x],
|
||||
((PNGU_u8 *) ctx->row_pointers[y]+x*6), ((PNGU_u8 *) ctx->row_pointers[y]+x*6+1),
|
||||
((PNGU_u8 *) ctx->row_pointers[y]+x*6+2), ((PNGU_u8 *) ctx->row_pointers[y]+x*6+3),
|
||||
((PNGU_u8 *) ctx->row_pointers[y]+x*6+4), ((PNGU_u8 *) ctx->row_pointers[y]+x*6+5) );
|
||||
PNGU_YCbYCr_TO_RGB8 ( ((uint32_t *)buffer)[y*buffWidth+x],
|
||||
((uint8_t *) ctx->row_pointers[y]+x*6), ((uint8_t *) ctx->row_pointers[y]+x*6+1),
|
||||
((uint8_t *) ctx->row_pointers[y]+x*6+2), ((uint8_t *) ctx->row_pointers[y]+x*6+3),
|
||||
((uint8_t *) ctx->row_pointers[y]+x*6+4), ((uint8_t *) ctx->row_pointers[y]+x*6+5) );
|
||||
}
|
||||
|
||||
// Tell libpng where is our image data
|
||||
|
|
@ -948,7 +951,7 @@ int PNGU_EncodeFromYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *bu
|
|||
|
||||
|
||||
// This function is taken from a libogc example
|
||||
PNGU_u32 PNGU_RGB8_TO_YCbYCr (PNGU_u8 r1, PNGU_u8 g1, PNGU_u8 b1, PNGU_u8 r2, PNGU_u8 g2, PNGU_u8 b2)
|
||||
uint32_t PNGU_RGB8_TO_YCbYCr (uint8_t r1, uint8_t g1, uint8_t b1, uint8_t r2, uint8_t g2, uint8_t b2)
|
||||
{
|
||||
const int y1 = (299 * r1 + 587 * g1 + 114 * b1) / 1000;
|
||||
const int cb1 = (-16874 * r1 - 33126 * g1 + 50000 * b1 + 12800000) / 100000;
|
||||
|
|
@ -961,13 +964,13 @@ PNGU_u32 PNGU_RGB8_TO_YCbYCr (PNGU_u8 r1, PNGU_u8 g1, PNGU_u8 b1, PNGU_u8 r2, PN
|
|||
const int cb = (cb1 + cb2) >> 1;
|
||||
const int cr = (cr1 + cr2) >> 1;
|
||||
|
||||
return (PNGU_u32) ((y1 << 24) | (cb << 16) | (y2 << 8) | cr);
|
||||
return (uint32_t) ((y1 << 24) | (cb << 16) | (y2 << 8) | cr);
|
||||
}
|
||||
|
||||
|
||||
void PNGU_YCbYCr_TO_RGB8 (PNGU_u32 ycbycr, PNGU_u8 *r1, PNGU_u8 *g1, PNGU_u8 *b1, PNGU_u8 *r2, PNGU_u8 *g2, PNGU_u8 *b2)
|
||||
void PNGU_YCbYCr_TO_RGB8 (uint32_t ycbycr, uint8_t *r1, uint8_t *g1, uint8_t *b1, uint8_t *r2, uint8_t *g2, uint8_t *b2)
|
||||
{
|
||||
const PNGU_u8 *val = (PNGU_u8 *) &ycbycr;
|
||||
const uint8_t *val = (uint8_t *) &ycbycr;
|
||||
|
||||
const int r = 1.371f * (val[3] - 128);
|
||||
const int g = - 0.698f * (val[3] - 128) - 0.336f * (val[1] - 128);
|
||||
|
|
@ -1163,15 +1166,14 @@ int pngu_info (IMGCTX ctx)
|
|||
}
|
||||
|
||||
|
||||
int pngu_decode (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, PNGU_u32 stripAlpha)
|
||||
int pngu_decode (IMGCTX ctx, uint32_t width, uint32_t height, uint32_t stripAlpha)
|
||||
{
|
||||
png_uint_32 rowbytes;
|
||||
int i;
|
||||
|
||||
// Read info if it hasn't been read before
|
||||
if (!ctx->infoRead)
|
||||
{
|
||||
i = pngu_info (ctx);
|
||||
const int i = pngu_info (ctx);
|
||||
if (i != PNGU_OK)
|
||||
return i;
|
||||
}
|
||||
|
|
@ -1223,7 +1225,7 @@ int pngu_decode (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, PNGU_u32 stripAlph
|
|||
return PNGU_LIB_ERROR;
|
||||
}
|
||||
|
||||
for (i = 0; i < ctx->prop.imgHeight; i++)
|
||||
for (uint32_t i = 0; i < ctx->prop.imgHeight; i++)
|
||||
{
|
||||
ctx->row_pointers[i] = ctx->img_data + (i * rowbytes);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,6 +10,8 @@ More info : http://frontier-dev.net
|
|||
#ifndef __PNGU__
|
||||
#define __PNGU__
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
// Return codes
|
||||
#define PNGU_OK 0
|
||||
#define PNGU_ODD_WIDTH 1
|
||||
|
|
@ -35,28 +37,22 @@ More info : http://frontier-dev.net
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
// Types
|
||||
typedef unsigned char PNGU_u8;
|
||||
typedef unsigned short PNGU_u16;
|
||||
typedef unsigned int PNGU_u32;
|
||||
typedef unsigned long long PNGU_u64;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
PNGU_u8 r;
|
||||
PNGU_u8 g;
|
||||
PNGU_u8 b;
|
||||
uint8_t r;
|
||||
uint8_t g;
|
||||
uint8_t b;
|
||||
} PNGUCOLOR;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
PNGU_u32 imgWidth; // In pixels
|
||||
PNGU_u32 imgHeight; // In pixels
|
||||
PNGU_u32 imgBitDepth; // In bitx
|
||||
PNGU_u32 imgColorType; // PNGU_COLOR_TYPE_*
|
||||
PNGU_u32 validBckgrnd; // Non zero if there is a background color
|
||||
uint32_t imgWidth; // In pixels
|
||||
uint32_t imgHeight; // In pixels
|
||||
uint32_t imgBitDepth; // In bitx
|
||||
uint32_t imgColorType; // PNGU_COLOR_TYPE_*
|
||||
uint32_t validBckgrnd; // Non zero if there is a background color
|
||||
PNGUCOLOR bckgrnd; // Background color
|
||||
PNGU_u32 numTrans; // Number of transparent colors
|
||||
uint32_t numTrans; // Number of transparent colors
|
||||
PNGUCOLOR *trans; // Transparent colors
|
||||
} PNGUPROP;
|
||||
|
||||
|
|
@ -70,18 +66,18 @@ typedef struct _IMGCTX *IMGCTX;
|
|||
****************************************************************************/
|
||||
|
||||
// Macro to convert RGB8 values to RGB565
|
||||
#define PNGU_RGB8_TO_RGB565(r,g,b) ( ((((PNGU_u16) r) & 0xF8U) << 8) | ((((PNGU_u16) g) & 0xFCU) << 3) | (((PNGU_u16) b) >> 3) )
|
||||
#define PNGU_RGB8_TO_RGB565(r,g,b) ( ((((uint16_t) r) & 0xF8U) << 8) | ((((uint16_t) g) & 0xFCU) << 3) | (((uint16_t) b) >> 3) )
|
||||
|
||||
// Macro to convert RGBA8 values to RGB5A3
|
||||
#define PNGU_RGB8_TO_RGB5A3(r,g,b,a) (PNGU_u16) (((a & 0xE0U) == 0xE0U) ? \
|
||||
(0x8000U | ((((PNGU_u16) r) & 0xF8U) << 7) | ((((PNGU_u16) g) & 0xF8U) << 2) | (((PNGU_u16) b) >> 3)) : \
|
||||
(((((PNGU_u16) a) & 0xE0U) << 7) | ((((PNGU_u16) r) & 0xF0U) << 4) | (((PNGU_u16) g) & 0xF0U) | ((((PNGU_u16) b) & 0xF0U) >> 4)))
|
||||
#define PNGU_RGB8_TO_RGB5A3(r,g,b,a) (uint16_t) (((a & 0xE0U) == 0xE0U) ? \
|
||||
(0x8000U | ((((uint16_t) r) & 0xF8U) << 7) | ((((uint16_t) g) & 0xF8U) << 2) | (((uint16_t) b) >> 3)) : \
|
||||
(((((uint16_t) a) & 0xE0U) << 7) | ((((uint16_t) r) & 0xF0U) << 4) | (((uint16_t) g) & 0xF0U) | ((((uint16_t) b) & 0xF0U) >> 4)))
|
||||
|
||||
// Function to convert two RGB8 values to YCbYCr
|
||||
PNGU_u32 PNGU_RGB8_TO_YCbYCr (PNGU_u8 r1, PNGU_u8 g1, PNGU_u8 b1, PNGU_u8 r2, PNGU_u8 g2, PNGU_u8 b2);
|
||||
uint32_t PNGU_RGB8_TO_YCbYCr (uint8_t r1, uint8_t g1, uint8_t b1, uint8_t r2, uint8_t g2, uint8_t b2);
|
||||
|
||||
// Function to convert an YCbYCr to two RGB8 values.
|
||||
void PNGU_YCbYCr_TO_RGB8 (PNGU_u32 ycbycr, PNGU_u8 *r1, PNGU_u8 *g1, PNGU_u8 *b1, PNGU_u8 *r2, PNGU_u8 *g2, PNGU_u8 *b2);
|
||||
void PNGU_YCbYCr_TO_RGB8 (uint32_t ycbycr, uint8_t *r1, uint8_t *g1, uint8_t *b1, uint8_t *r2, uint8_t *g2, uint8_t *b2);
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
|
|
@ -112,7 +108,7 @@ int PNGU_GetImageProperties (IMGCTX ctx, PNGUPROP *fileproperties);
|
|||
|
||||
// Expands selected image into an YCbYCr buffer. You need to specify context, image dimensions,
|
||||
// destination address and stride in pixels (stride = buffer width - image width).
|
||||
int PNGU_DecodeToYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride);
|
||||
int PNGU_DecodeToYCbYCr (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer, uint32_t stride);
|
||||
|
||||
// Macro for decoding an image inside a buffer at given coordinates.
|
||||
#define PNGU_DECODE_TO_COORDS_YCbYCr(ctx,coordX,coordY,imgWidth,imgHeight,bufferWidth,bufferHeight,buffer) \
|
||||
|
|
@ -122,7 +118,7 @@ int PNGU_DecodeToYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buff
|
|||
|
||||
// Expands selected image into a linear RGB565 buffer. You need to specify context, image dimensions,
|
||||
// destination address and stride in pixels (stride = buffer width - image width).
|
||||
int PNGU_DecodeToRGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride);
|
||||
int PNGU_DecodeToRGB565 (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer, uint32_t stride);
|
||||
|
||||
// Macro for decoding an image inside a buffer at given coordinates.
|
||||
#define PNGU_DECODE_TO_COORDS_RGB565(ctx,coordX,coordY,imgWidth,imgHeight,bufferWidth,bufferHeight,buffer) \
|
||||
|
|
@ -133,7 +129,7 @@ int PNGU_DecodeToRGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buff
|
|||
// Expands selected image into a linear RGBA8 buffer. You need to specify context, image dimensions,
|
||||
// destination address, stride in pixels and default alpha value, which is used if the source image
|
||||
// doesn't have an alpha channel.
|
||||
int PNGU_DecodeToRGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride, PNGU_u8 default_alpha);
|
||||
int PNGU_DecodeToRGBA8 (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer, uint32_t stride, uint8_t default_alpha);
|
||||
|
||||
// Macro for decoding an image inside a buffer at given coordinates.
|
||||
#define PNGU_DECODE_TO_COORDS_RGBA8(ctx,coordX,coordY,imgWidth,imgHeight,default_alpha,bufferWidth,bufferHeight,buffer) \
|
||||
|
|
@ -143,23 +139,23 @@ int PNGU_DecodeToRGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffe
|
|||
|
||||
// Expands selected image into a 4x4 tiled RGB565 buffer. You need to specify context, image dimensions
|
||||
// and destination address.
|
||||
int PNGU_DecodeTo4x4RGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer);
|
||||
int PNGU_DecodeTo4x4RGB565 (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer);
|
||||
|
||||
// Expands selected image into a 4x4 tiled RGB5A3 buffer. You need to specify context, image dimensions,
|
||||
// destination address and default alpha value, which is used if the source image doesn't have an alpha channel.
|
||||
int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u8 default_alpha);
|
||||
int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer, uint8_t default_alpha);
|
||||
|
||||
// Expands selected image into a 4x4 tiled RGBA8 buffer. You need to specify context, image dimensions,
|
||||
// destination address.
|
||||
PNGU_u8 * PNGU_DecodeTo4x4RGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, int * dstWidth, int * dstHeight);
|
||||
uint8_t * PNGU_DecodeTo4x4RGBA8 (IMGCTX ctx, uint32_t width, uint32_t height, int * dstWidth, int * dstHeight);
|
||||
|
||||
// Encodes an YCbYCr image in PNG format and stores it in the selected device or memory buffer. You need to
|
||||
// specify context, image dimensions, destination address and stride in pixels (stride = buffer width - image width).
|
||||
int PNGU_EncodeFromYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride);
|
||||
int PNGU_EncodeFromYCbYCr (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer, uint32_t stride);
|
||||
|
||||
int PNGU_EncodeFromRGB (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride);
|
||||
int PNGU_EncodeFromGXTexture (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride);
|
||||
int PNGU_EncodeFromEFB (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, PNGU_u32 stride);
|
||||
int PNGU_EncodeFromRGB (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer, uint32_t stride);
|
||||
int PNGU_EncodeFromGXTexture (IMGCTX ctx, uint32_t width, uint32_t height, void *buffer, uint32_t stride);
|
||||
int PNGU_EncodeFromEFB (IMGCTX ctx, uint32_t width, uint32_t height, uint32_t stride);
|
||||
|
||||
// Macro for encoding an image stored into an YCbYCr buffer at given coordinates.
|
||||
#define PNGU_ENCODE_TO_COORDS_YCbYCr(ctx,coordX,coordY,imgWidth,imgHeight,bufferWidth,bufferHeight,buffer) \
|
||||
|
|
|
|||
Loading…
Reference in a new issue