static rt_bool_t rtgui_image_hdc_check(struct rtgui_filerw *file)
{
int start;
rt_bool_t is_HDC;
rt_uint8_t magic[4];
if (!file) return 0;
start = rtgui_filerw_tell(file);
/* move to the beginning of file */
rtgui_filerw_seek(file, 0, RTGUI_FILE_SEEK_SET);
is_HDC = RT_FALSE;
if (rtgui_filerw_read(file, magic, 1, sizeof(magic)) == sizeof(magic))
{
if (magic[0] == 'H' &&
magic[1] == 'D' &&
magic[2] == 'C' &&
magic[3] == '\0')
{
is_HDC = RT_TRUE;
}
}
rtgui_filerw_seek(file, start, RTGUI_FILE_SEEK_SET);
return(is_HDC);
}
static rt_bool_t rtgui_image_png_check(struct rtgui_filerw *file)
{
int start;
rt_bool_t is_PNG;
rt_uint8_t magic[4];
if (!file) return 0;
start = rtgui_filerw_tell(file);
/* move to the begining of file */
rtgui_filerw_seek(file, 0, SEEK_SET);
is_PNG = RT_FALSE;
if (rtgui_filerw_read(file, magic, 1, sizeof(magic)) == sizeof(magic))
{
if (magic[0] == 0x89 &&
magic[1] == 'P' &&
magic[2] == 'N' &&
magic[3] == 'G')
{
is_PNG = RT_TRUE;
}
}
rtgui_filerw_seek(file, start, SEEK_SET);
return(is_PNG);
}
static rt_bool_t rtgui_image_bmp_check(struct rtgui_filerw* file)
{
char magic[2];
rt_bool_t is_bmp;
rt_off_t start;
if ( !file ) return 0;
start = rtgui_filerw_tell(file);
/* move to the beginning of file */
rtgui_filerw_seek(file, 0, RTGUI_FILE_SEEK_SET);
is_bmp = RT_FALSE;
if ( rtgui_filerw_read(file, magic, 1, sizeof(magic)) == sizeof(magic) )
{
if (magic[0] == 'B' &&
magic[1] == 'M')
{
is_bmp = RT_TRUE;
}
}
rtgui_filerw_seek(file, start, RTGUI_FILE_SEEK_SET);
return(is_bmp);
}
static void rtgui_image_hdc_blit(struct rtgui_image *image, struct rtgui_dc *dc, struct rtgui_rect *dst_rect)
{
rt_uint16_t y, w, h;
struct rtgui_image_hdc *hdc;
RT_ASSERT(image != RT_NULL || dc != RT_NULL || dst_rect != RT_NULL);
/* this dc is not visible */
if (rtgui_dc_get_visible(dc) != RT_TRUE) return;
hdc = (struct rtgui_image_hdc *) image->data;
RT_ASSERT(hdc != RT_NULL);
/* the minimum rect */
if (image->w < rtgui_rect_width(*dst_rect)) w = image->w;
else w = rtgui_rect_width(*dst_rect);
if (image->h < rtgui_rect_height(*dst_rect)) h = image->h;
else h = rtgui_rect_height(*dst_rect);
if (hdc->pixels != RT_NULL)
{
rt_uint8_t *ptr;
/* get pixel pointer */
ptr = hdc->pixels;
for (y = 0; y < h; y ++)
{
dc->engine->blit_line(dc, dst_rect->x1, dst_rect->x1 + w, dst_rect->y1 + y, ptr);
ptr += hdc->pitch;
}
}
else
{
rt_uint8_t *ptr;
ptr = rtgui_malloc(hdc->pitch);
if (ptr == RT_NULL) return; /* no memory */
/* seek to the begin of pixel data */
rtgui_filerw_seek(hdc->filerw, hdc->pixel_offset, RTGUI_FILE_SEEK_SET);
for (y = 0; y < h; y ++)
{
/* read pixel data */
if (rtgui_filerw_read(hdc->filerw, ptr, 1, hdc->pitch) != hdc->pitch)
break; /* read data failed */
dc->engine->blit_line(dc, dst_rect->x1, dst_rect->x1 + w, dst_rect->y1 + y, ptr);
}
rtgui_free(ptr);
}
}
static rt_bool_t rtgui_image_bmp_check(struct rtgui_filerw *file)
{
rt_uint8_t buffer[18];
rt_bool_t is_bmp = RT_FALSE;
do
{
if (!file)
{
break;
}
/* Prepare to decode */
if (rtgui_filerw_seek(file, 0, RTGUI_FILE_SEEK_SET) < 0)
{
break;
}
if (rtgui_filerw_read(file, (void *)buffer, 18, 1) != 18)
{
break;
}
/* Read file type */
if (buffer[0] != 'B' || buffer[1] != 'M')
{
break;
}
/* Read BMP header size */
if (*(rt_uint32_t *)&buffer[14] == 12)
{
/* Bitmap Header Version 2.x */
if (rtgui_filerw_read(file, (void *)buffer, 8, 1) != 8)
{
break;
}
/* Read image size */
is_bmp = RT_TRUE;
}
else
{
/* Bitmap Header Version bigger than 2.x */
if (rtgui_filerw_read(file, (void *)buffer, 8, 1) != 8)
{
break;
}
/* Read image size */
is_bmp = RT_TRUE;
}
}
while (0);
return is_bmp;
}
static rt_bool_t rtgui_image_bmp_load(struct rtgui_image *image, struct rtgui_filerw *file, rt_bool_t load)
{
rt_uint8_t scale = 0;
rt_uint8_t *wrkBuffer;
struct rtgui_image_bmp *bmp;
rt_uint32_t bmpHeaderSize;
rt_uint32_t colorsUsed;
if (scale > BMP_MAX_SCALING_FACTOR)
{
return RT_FALSE;
}
do
{
wrkBuffer = (rt_uint8_t *)rtgui_malloc(BMP_WORKING_BUFFER_SIZE);
if (wrkBuffer == RT_NULL)
{
rt_kprintf("BMP err: no mem\n");
break;
}
bmp = (struct rtgui_image_bmp *)rtgui_malloc(sizeof(struct rtgui_image_bmp));
if (bmp == RT_NULL)
{
break;
}
/* Prepare to decode */
if (rtgui_filerw_seek(file, 0, RTGUI_FILE_SEEK_SET) < 0)
{
break;
}
if (rtgui_filerw_read(file, (void *)wrkBuffer, 18, 1) != 18)
{
break;
}
/* Read file type */
if (wrkBuffer[0] != 'B' || wrkBuffer[1] != 'M')
{
break;
}
// rt_kprintf("BMP: format ok\n");
/* Read pixel array offset */
bmp->pixel_offset = *(rt_uint32_t *)&wrkBuffer[10];
// rt_kprintf("BMP: bmp->pixel_offset %d\n", bmp->pixel_offset);
/* Read BMP header size */
bmpHeaderSize = *(rt_uint32_t *)&wrkBuffer[14];
// rt_kprintf("BMP: bmpHeaderSize %d\n", bmpHeaderSize);
colorsUsed = 0;
if (bmpHeaderSize == 12)
{
/* Bitmap Header Version 2.x */
if (rtgui_filerw_read(file, (void *)wrkBuffer, 8, 1) != 8)
{
break;
}
/* Read image size */
bmp->w = (rt_uint32_t) * (rt_uint16_t *)&wrkBuffer[0];
bmp->h = (rt_uint32_t) * (rt_uint16_t *)&wrkBuffer[2];
/* Read bits per pixel */
bmp->bit_per_pixel = (rt_uint8_t) * (rt_uint16_t *)&wrkBuffer[6];
}
else
{
/* Bitmap Header Version bigger than 2.x */
rt_uint32_t compression;
if (rtgui_filerw_read(file, (void *)wrkBuffer, 36, 1) != 36)
{
break;
}
/* Read image size */
bmp->w = *(rt_uint32_t *)&wrkBuffer[0];
bmp->h = *(rt_uint32_t *)&wrkBuffer[4];
/* Read bits per pixel */
bmp->bit_per_pixel = (rt_uint8_t) * (rt_uint16_t *)&wrkBuffer[10];
if (bmp->bit_per_pixel > 32)
{
rt_kprintf("BMP err: unsupported format\n");
break;
}
/* Read compression method */
compression = *(rt_uint32_t *)&wrkBuffer[12];
if (compression != BI_RGB && compression != BI_BITFIELDS)
{
rt_kprintf("BMP err: unsupported format\n");
break;
}
/* Read number of colors */
colorsUsed = *(rt_uint32_t *)&wrkBuffer[28];
}
if (!colorsUsed)
{
colorsUsed = 1 << bmp->bit_per_pixel;
}
/* Load palette */
if (bmp->bit_per_pixel <= 8)
{
if (rtgui_filerw_seek(file, 14 + bmpHeaderSize, RTGUI_FILE_SEEK_SET) < 0)
{
break;
}
image->palette = rtgui_image_bmp_load_palette(file, colorsUsed,
bmpHeaderSize > 12 ? RT_TRUE : RT_FALSE);
if (image->palette == RT_NULL)
{
break;
}
}
/* Set image information */
bmp->is_loaded = RT_FALSE;
bmp->scale = scale;
if (bmp->bit_per_pixel == 1)
{
bmp->pitch = (bmp->w + 7) >> 3;
}
else if (bmp->bit_per_pixel == 4)
{
bmp->pitch = (bmp->w + 1) >> 1;
}
static rt_bool_t rtgui_image_png_load(struct rtgui_image *image, struct rtgui_filerw *file, rt_bool_t load)
{
unsigned int width;
unsigned int height;
unsigned int error;
rt_uint8_t* pixel;
rt_uint8_t* in;
rt_uint32_t in_size;
RT_ASSERT(image != RT_NULL);
RT_ASSERT(file != RT_NULL);
rtgui_filerw_seek(file, 0, SEEK_END);
in_size = rtgui_filerw_tell(file);
in = rtgui_malloc(in_size);
if (in == RT_NULL) return RT_FALSE; /* out of memory */
rtgui_filerw_seek(file, 0, SEEK_SET);
rtgui_filerw_read(file, in, in_size, 1);
error = lodepng_decode32(&pixel, &width, &height, in, in_size);
if(error)
{
rt_kprintf("error %u: %s\n", error, lodepng_error_text(error));
rtgui_free(in);
return RT_FALSE;
}
rtgui_free(in);
/* set image information */
image->w = width;
image->h = height;
image->engine = &rtgui_image_png_engine;
image->data = pixel;
/* NOTE: the pixel format of PNG is ABGR888, bit0 R,G,B,A bit31 */
/* convert pixel to ARGB888, swap B/G */
{
rt_uint8_t* pixel_ptr;
rt_uint8_t* pixel_end;
pixel_ptr = (rt_uint8_t*) pixel;
pixel_end = pixel_ptr + width * height * 4;
while (pixel_ptr < pixel_end)
{
pixel_ptr[0] = pixel_ptr[0] ^ pixel_ptr[2];
pixel_ptr[2] = pixel_ptr[0] ^ pixel_ptr[2];
pixel_ptr[0] = pixel_ptr[0] ^ pixel_ptr[2];
pixel_ptr += 4;
}
}
/* close file handler */
rtgui_filerw_close(file);
return RT_TRUE;
}
static rt_bool_t rtgui_image_bmp_load(struct rtgui_image* image, struct rtgui_filerw* src, rt_bool_t load)
{
rt_uint32_t Rmask;
rt_uint32_t Gmask;
rt_uint32_t Bmask;
int ExpandBMP, bmpPitch;
struct rtgui_image_bmp* bmp;
struct rtgui_image_bmp_header* header;
struct rtgui_image_palette* palette;
bmp = RT_NULL;
header = RT_NULL;
palette = RT_NULL;
header = (struct rtgui_image_bmp_header*) rtgui_malloc(sizeof(struct rtgui_image_bmp_header));
if (header == RT_NULL) return RT_FALSE;
if ( rtgui_filerw_read(src, header->magic, 1, sizeof(header->magic)) ==
sizeof(sizeof(header->magic)) )
{
if (header->magic[0] != 'B' ||
header->magic[1] != 'M')
{
goto __exit;
}
}
header->bfSize = rtgui_filerw_read32(src);
header->bfReserved1 = rtgui_filerw_read16(src);
header->bfReserved2 = rtgui_filerw_read16(src);
header->bfOffBits = rtgui_filerw_read32(src);
/* Read the Win32 BITMAPINFOHEADER */
header->biSize = rtgui_filerw_read32(src);
if ( header->biSize == 12 )
{
header->biWidth = (rt_uint32_t)rtgui_filerw_read16(src);
header->biHeight = (rt_uint32_t)rtgui_filerw_read16(src);
header->biPlanes = rtgui_filerw_read16(src);
header->biBitCount = rtgui_filerw_read16(src);
header->biCompression = BI_RGB;
header->biSizeImage = 0;
header->biXPelsPerMeter = 0;
header->biYPelsPerMeter = 0;
header->biClrUsed = 0;
header->biClrImportant = 0;
}
else
{
header->biWidth = rtgui_filerw_read32(src);
header->biHeight = rtgui_filerw_read32(src);
header->biPlanes = rtgui_filerw_read16(src);
header->biBitCount = rtgui_filerw_read16(src);
header->biCompression = rtgui_filerw_read32(src);
header->biSizeImage = rtgui_filerw_read32(src);
header->biXPelsPerMeter = rtgui_filerw_read32(src);
header->biYPelsPerMeter = rtgui_filerw_read32(src);
header->biClrUsed = rtgui_filerw_read32(src);
header->biClrImportant = rtgui_filerw_read32(src);
}
/* allocate palette and expand 1 and 4 bit bitmaps to 8 bits per pixel */
switch (header->biBitCount)
{
case 1:
ExpandBMP = header->biBitCount;
palette = rtgui_image_bmp_load_palette(header, src);
header->biBitCount = 8;
break;
case 4:
ExpandBMP = header->biBitCount;
palette = rtgui_image_bmp_load_palette(header, src);
header->biBitCount = 8;
break;
case 8:
palette = rtgui_image_bmp_load_palette(header, src);
ExpandBMP = 0;
break;
default:
ExpandBMP = 0;
break;
}
/* We don't support any BMP compression right now */
Rmask = Gmask = Bmask = 0;
switch (header->biCompression)
{
case BI_RGB:
/* If there are no masks, use the defaults */
if ( header->bfOffBits == (14 + header->biSize) )
{
/* Default values for the BMP format */
switch (header->biBitCount)
{
case 15:
case 16:
Rmask = 0x7C00;
Gmask = 0x03E0;
Bmask = 0x001F;
break;
case 24:
case 32:
Rmask = 0x00FF0000;
Gmask = 0x0000FF00;
Bmask = 0x000000FF;
break;
default:
break;
}
break;
}
/* Fall through -- read the RGB masks */
case BI_BITFIELDS:
switch (header->biBitCount)
{
case 15:
case 16:
case 32:
Rmask = rtgui_filerw_read32(src);
Gmask = rtgui_filerw_read32(src);
Bmask = rtgui_filerw_read32(src);
break;
default:
break;
}
break;
default:
rt_kprintf("Compressed BMP files not supported\n");
goto __exit;
}
bmp = (struct rtgui_image_bmp*) rtgui_malloc(sizeof(struct rtgui_image_bmp));
if (bmp == RT_NULL)
goto __exit;
/* set image information */
image->w = header->biWidth;
image->h = header->biHeight;
image->engine = &rtgui_image_bmp_engine;
image->data = bmp;
bmp->filerw = src;
bmp->byte_per_pixel = header->biBitCount/8;
bmp->pitch = image->w * bmp->byte_per_pixel;
bmp->pixel_offset = header->bfOffBits;
bmp->Rmask = Rmask; bmp->Gmask = Gmask; bmp->Bmask = Bmask;
bmp->ExpandBMP = ExpandBMP;
if (palette != RT_NULL) image->palette = palette;
/* get padding */
switch (ExpandBMP)
{
case 1:
bmpPitch = (header->biWidth + 7) >> 3;
bmp->pad = (((bmpPitch)%4) ? (4-((bmpPitch)%4)) : 0);
break;
case 4:
bmpPitch = (header->biWidth + 1) >> 1;
bmp->pad = (((bmpPitch)%4) ? (4-((bmpPitch)%4)) : 0);
break;
default:
bmp->pad = ((bmp->pitch%4) ? (4-(bmp->pitch%4)) : 0);
break;
}
if (load == RT_TRUE)
{
rt_uint8_t *bits;
rt_uint32_t i;
/* load all pixels */
bmp->pixels = rtgui_malloc(image->h * bmp->pitch);
if (bmp->pixels == RT_NULL)
goto __exit;
/* Read the pixels. Note that the bmp image is upside down */
if ( rtgui_filerw_seek(src, bmp->pixel_offset, RTGUI_FILE_SEEK_SET) < 0)
goto __exit;
bits = bmp->pixels + image->h * bmp->pitch;
while ( bits > bmp->pixels )
{
bits -= bmp->pitch;
switch (ExpandBMP)
{
case 1:
case 4:
{
rt_uint8_t pixel = 0;
int shift = (8 - ExpandBMP);
for ( i=0; i < image->w; ++i )
{
if ( i % (8/ExpandBMP) == 0 )
{
if ( !rtgui_filerw_read(src, &pixel, 1, 1) )
goto __exit;
}
*(bits+i) = (pixel>>shift);
pixel <<= ExpandBMP;
}
}
break;
default:
if ( rtgui_filerw_read(src, bits, 1, bmp->pitch) != bmp->pitch ) goto __exit;
break;
}
/* Skip padding bytes */
if ( bmp->pad )
{
rt_uint8_t padbyte;
for ( i=0; i < bmp->pad; ++i )
{
rtgui_filerw_read(src, &padbyte, 1, 1);
}
}
}
rtgui_filerw_close(bmp->filerw);
bmp->line_pixels = RT_NULL;
bmp->filerw = RT_NULL;
bmp->pixel_offset = 0;
}