825 lines
26 KiB
C
825 lines
26 KiB
C
/*
|
|
* Change Logs:
|
|
* Date Author Notes
|
|
* 2012-01-24 onelife Reimplement to improve efficiency and add
|
|
* features. The new decoder uses configurable fixed size working buffer and
|
|
* provides scaledown function.
|
|
*/
|
|
#include <rtthread.h>
|
|
#include <rtgui/dc_hw.h>
|
|
#include <rtgui/image.h>
|
|
#include <rtgui/rtgui_system.h>
|
|
#include <rtgui/image_bmp.h>
|
|
#include <rtgui/blit.h>
|
|
|
|
#ifdef RTGUI_USING_DFS_FILERW
|
|
#include <dfs_posix.h>
|
|
#endif
|
|
|
|
#ifdef RTGUI_IMAGE_BMP
|
|
/* Compression encodings for BMP files */
|
|
#ifndef BI_RGB
|
|
#define BI_RGB 0
|
|
#define BI_RLE8 1
|
|
#define BI_RLE4 2
|
|
#define BI_BITFIELDS 3
|
|
#endif
|
|
|
|
#define BMP_WORKING_BUFFER_SIZE (384) /* In multiple of 12 and bigger than 48 */
|
|
#define BMP_MAX_SCALING_FACTOR (10) // TODO: find the max value!
|
|
#define hw_driver (rtgui_graphic_driver_get_default())
|
|
|
|
struct rtgui_image_bmp
|
|
{
|
|
rt_bool_t is_loaded;
|
|
rt_uint8_t *pixels;
|
|
struct rtgui_filerw* filerw;
|
|
rt_uint32_t w, h;
|
|
rt_uint32_t pixel_offset;
|
|
rt_uint32_t pitch; rt_uint8_t scale;
|
|
rt_uint8_t bit_per_pixel;
|
|
rt_uint8_t pad;
|
|
};
|
|
|
|
/* static rt_bool_t rtgui_image_bmp_check(struct rtgui_filerw* file,
|
|
rt_uint32_t *width, rt_uint32_t *height);
|
|
static rt_bool_t rtgui_image_bmp_load(struct rtgui_image* image,
|
|
struct rtgui_filerw* file, rt_uint8_t scale, rt_bool_t load); */
|
|
static rt_bool_t rtgui_image_bmp_check(struct rtgui_filerw* file);
|
|
static rt_bool_t rtgui_image_bmp_load(struct rtgui_image* image, struct rtgui_filerw* file, rt_bool_t load);
|
|
static void rtgui_image_bmp_unload(struct rtgui_image* image);
|
|
static void rtgui_image_bmp_blit(struct rtgui_image* image, struct rtgui_dc* dc, struct rtgui_rect* rect);
|
|
|
|
|
|
struct rtgui_image_engine rtgui_image_bmp_engine =
|
|
{
|
|
"bmp",
|
|
{ RT_NULL },
|
|
rtgui_image_bmp_check,
|
|
rtgui_image_bmp_load,
|
|
rtgui_image_bmp_unload,
|
|
rtgui_image_bmp_blit
|
|
};
|
|
|
|
static rt_bool_t rtgui_image_bmp_check(struct rtgui_filerw* file)
|
|
//static rt_bool_t rtgui_image_bmp_check(struct rtgui_filerw* file,
|
|
// rt_uint32_t *width, rt_uint32_t *height)
|
|
{
|
|
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 */
|
|
// *width = (rt_uint32_t)*(rt_uint16_t *)&buffer[0];
|
|
// *height = (rt_uint32_t)*(rt_uint16_t *)&buffer[2];
|
|
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 */
|
|
// *width = *(rt_uint32_t *)&buffer[0];
|
|
// *height = *(rt_uint32_t *)&buffer[4];
|
|
is_bmp = RT_TRUE;
|
|
}
|
|
} while(0);
|
|
|
|
return is_bmp;
|
|
}
|
|
|
|
static struct rtgui_image_palette* rtgui_image_bmp_load_palette(
|
|
struct rtgui_filerw* file,
|
|
rt_uint32_t colorsUsed,
|
|
rt_bool_t alpha)
|
|
{
|
|
/* Load the palette, if any */
|
|
rt_uint32_t i;
|
|
struct rtgui_image_palette *palette;
|
|
|
|
palette = rtgui_image_palette_create(colorsUsed);
|
|
if (palette == RT_NULL)
|
|
{
|
|
return RT_NULL;
|
|
}
|
|
|
|
if (alpha)
|
|
{
|
|
rt_uint8_t temp[4];
|
|
for (i = 0; i < colorsUsed; i++)
|
|
{
|
|
if (rtgui_filerw_read(file, (void *)&temp, 1, 4) != 4)
|
|
{
|
|
rtgui_free(palette);
|
|
return RT_NULL;
|
|
}
|
|
palette->colors[i] = RTGUI_ARGB(temp[3], temp[2], temp[1], temp[0]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rt_uint8_t temp[3];
|
|
for (i = 0; i < colorsUsed; i++)
|
|
{
|
|
if (rtgui_filerw_read(file, (void *)&temp, 1, 3) != 3)
|
|
{
|
|
rtgui_free(palette);
|
|
return RT_NULL;
|
|
}
|
|
palette->colors[i] = RTGUI_RGB(temp[2], temp[1], temp[0]);
|
|
}
|
|
}
|
|
|
|
return palette;
|
|
}
|
|
|
|
static rt_bool_t rtgui_image_bmp_load(struct rtgui_image* image, struct rtgui_filerw* file, rt_bool_t load)
|
|
//static rt_bool_t rtgui_image_bmp_load(struct rtgui_image* image,
|
|
// struct rtgui_filerw* file, rt_uint8_t scale, rt_bool_t load)
|
|
{
|
|
rt_uint8_t scale = 2;
|
|
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 *)rt_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;
|
|
}
|
|
else
|
|
{
|
|
bmp->pitch = bmp->w * (bmp->bit_per_pixel >> 3);
|
|
}
|
|
bmp->pad = ((bmp->pitch % 4) ? (4 - (bmp->pitch % 4)) : 0);
|
|
bmp->pixels = RT_NULL;
|
|
bmp->filerw = file;
|
|
|
|
image->w = bmp->w >> bmp->scale;
|
|
image->h = bmp->h >> bmp->scale;
|
|
image->engine = &rtgui_image_bmp_engine;
|
|
image->data = bmp;
|
|
|
|
/* Start to decode */
|
|
if (load == RT_TRUE)
|
|
{
|
|
rt_bool_t error = RT_FALSE;
|
|
rt_uint8_t *dst;
|
|
rt_uint32_t imageWidth;
|
|
rt_uint16_t readLength, readIndex, loadIndex;
|
|
rt_uint8_t skipLength;
|
|
rt_uint16_t y;
|
|
rt_uint8_t bytePerPixel;
|
|
rt_int8_t scale1, scale2;
|
|
|
|
bytePerPixel = bmp->bit_per_pixel / 8;
|
|
if (!bytePerPixel)
|
|
{
|
|
bytePerPixel = 1;
|
|
}
|
|
imageWidth = image->w * bytePerPixel; /* Scaled width in byte */
|
|
bmp->pixels = rtgui_malloc(image->h * imageWidth);
|
|
if (bmp->pixels == RT_NULL)
|
|
{
|
|
rt_kprintf("BMP err: no mem to load (%d)\n", image->h * imageWidth);
|
|
break;
|
|
}
|
|
|
|
/* Read the pixels. Note that the bmp image is upside down */
|
|
if (rtgui_filerw_seek(file, bmp->pixel_offset, RTGUI_FILE_SEEK_SET) < 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (bmp->bit_per_pixel == 1)
|
|
{
|
|
if (bmp->scale > 3)
|
|
{
|
|
scale1 = bmp->scale - 3;
|
|
scale2 = 3;
|
|
}
|
|
else
|
|
{
|
|
scale1 = 0;
|
|
scale2 = bmp->scale;
|
|
}
|
|
}
|
|
else if (bmp->bit_per_pixel == 4)
|
|
{
|
|
if (bmp->scale > 1)
|
|
{
|
|
scale1 = bmp->scale - 1;
|
|
scale2 = 1;
|
|
}
|
|
else
|
|
{
|
|
scale1 = 0;
|
|
scale2 = bmp->scale;
|
|
}
|
|
}
|
|
|
|
/* Process whole image */
|
|
y = 0;
|
|
while (y < image->h)
|
|
{
|
|
dst = bmp->pixels + (image->h - y - 1) * imageWidth;
|
|
readIndex = 0;
|
|
skipLength= 0;
|
|
|
|
/* Process a line */
|
|
while (readIndex < bmp->pitch)
|
|
{
|
|
/* Put progress indicator */
|
|
rt_kprintf("\r%lu%%", y * 100UL / image->h);
|
|
|
|
/* Read data to buffer */
|
|
readLength = (BMP_WORKING_BUFFER_SIZE > (bmp->pitch - readIndex)) ? \
|
|
(bmp->pitch - readIndex) : BMP_WORKING_BUFFER_SIZE;
|
|
if (rtgui_filerw_read(file, (void *)wrkBuffer, 1, readLength) != readLength)
|
|
{
|
|
rt_kprintf("BMP err: read failed\n");
|
|
error = RT_TRUE;
|
|
break;
|
|
}
|
|
readIndex += readLength;
|
|
|
|
/* Process read buffer */
|
|
if (bmp->bit_per_pixel == 1)
|
|
{
|
|
rt_uint8_t j;
|
|
|
|
for (loadIndex = skipLength; loadIndex < readLength; loadIndex += 1 << scale1)
|
|
{
|
|
for (j = 0; j < 8; j += 1 << scale2)
|
|
{
|
|
*(dst++) = (wrkBuffer[loadIndex] & (1 << (7 - j))) >> (7 - j);
|
|
}
|
|
}
|
|
if (scale1 && (readLength % (1 << scale1)))
|
|
{
|
|
skipLength = (1 << scale1) - readLength % (1 << scale1);
|
|
}
|
|
}
|
|
else if (bmp->bit_per_pixel == 4)
|
|
{
|
|
rt_uint8_t j;
|
|
|
|
for (loadIndex = skipLength; loadIndex < readLength; loadIndex += 1 << scale1)
|
|
{
|
|
for (j = 0; j < 8; j += 1 << (2 + scale2))
|
|
{
|
|
*(dst++) = (wrkBuffer[loadIndex] & (0x0F << (4 - j))) >> (4 - j);
|
|
}
|
|
}
|
|
if (scale1 && (readLength % (1 << scale1)))
|
|
{
|
|
skipLength = (1 << scale1) - readLength % (1 << scale1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bmp->scale == 0)
|
|
{
|
|
rt_memcpy((void *)dst, (void *)wrkBuffer, readLength);
|
|
dst += readLength;
|
|
}
|
|
else
|
|
{
|
|
for (loadIndex = skipLength; loadIndex < readLength; loadIndex += bytePerPixel << bmp->scale)
|
|
{
|
|
rt_memcpy((void *)dst, (void *)&wrkBuffer[loadIndex], bytePerPixel);
|
|
dst += bytePerPixel;
|
|
}
|
|
if (readLength % (1 << bmp->scale))
|
|
{
|
|
skipLength = (1 << bmp->scale) - readLength % (1 << bmp->scale);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (error)
|
|
{
|
|
break;
|
|
}
|
|
y++;
|
|
|
|
/* Skip padding bytes */
|
|
if (bmp->pad)
|
|
{
|
|
if ( rtgui_filerw_seek(file, bmp->pad, RTGUI_FILE_SEEK_CUR) < 0)
|
|
{
|
|
error = RT_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Height scale down */
|
|
if (bmp->scale)
|
|
{
|
|
if (rtgui_filerw_seek(file, (bmp->pitch + bmp->pad) * ((1 << bmp->scale) - 1),
|
|
RTGUI_FILE_SEEK_CUR) < 0)
|
|
{
|
|
error = RT_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (error)
|
|
{
|
|
break;
|
|
}
|
|
/* Close file */
|
|
rtgui_filerw_close(bmp->filerw);
|
|
bmp->filerw = RT_NULL;
|
|
bmp->is_loaded = RT_TRUE;
|
|
// rt_kprintf("BMP: load to RAM\n");
|
|
}
|
|
|
|
/* Release memory */
|
|
rt_free(wrkBuffer);
|
|
return RT_TRUE;
|
|
} while(0);
|
|
|
|
/* Release memory */
|
|
rt_free(wrkBuffer);
|
|
rtgui_free(image->palette);
|
|
rtgui_free(bmp->pixels);
|
|
rtgui_free(bmp);
|
|
return RT_FALSE;
|
|
}
|
|
|
|
static void rtgui_image_bmp_unload(struct rtgui_image* image)
|
|
{
|
|
struct rtgui_image_bmp* bmp;
|
|
|
|
if (image != RT_NULL)
|
|
{
|
|
bmp = (struct rtgui_image_bmp*)image->data;
|
|
|
|
/* Release memory */
|
|
rtgui_free(bmp->pixels);
|
|
if (bmp->filerw != RT_NULL)
|
|
{
|
|
/* Close file */
|
|
rtgui_filerw_close(bmp->filerw);
|
|
bmp->filerw = RT_NULL;
|
|
}
|
|
rtgui_free(bmp);
|
|
}
|
|
}
|
|
|
|
static void rtgui_image_bmp_blit(struct rtgui_image* image, struct rtgui_dc* dc, struct rtgui_rect* dst_rect)
|
|
{
|
|
rt_uint16_t w, h;
|
|
struct rtgui_image_bmp* bmp;
|
|
rt_uint8_t bytePerPixel;
|
|
rt_uint32_t imageWidth;
|
|
rt_bool_t error;
|
|
|
|
bmp = (struct rtgui_image_bmp*)image->data;
|
|
RT_ASSERT(image != RT_NULL || dc != RT_NULL || dst_rect != RT_NULL || bmp != RT_NULL);
|
|
|
|
bytePerPixel = bmp->bit_per_pixel / 8;
|
|
if (!bytePerPixel)
|
|
{
|
|
bytePerPixel = 1;
|
|
}
|
|
imageWidth = image->w * bytePerPixel; /* Scaled width in byte */
|
|
error = RT_FALSE;
|
|
|
|
do
|
|
{
|
|
/* this dc is not visible */
|
|
if (rtgui_dc_get_visible(dc) != RT_TRUE)
|
|
{
|
|
break;
|
|
}
|
|
|
|
/* 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 (!bmp->is_loaded)
|
|
{
|
|
rt_uint8_t *wrkBuffer;
|
|
rt_uint16_t readLength, readIndex, loadIndex;
|
|
rt_uint8_t skipLength;
|
|
rt_uint16_t x, y;
|
|
rt_int8_t scale1, scale2;
|
|
|
|
wrkBuffer = (rt_uint8_t *)rt_malloc(BMP_WORKING_BUFFER_SIZE);
|
|
if (wrkBuffer == RT_NULL)
|
|
{
|
|
rt_kprintf("BMP err: no mem (%d)\n", BMP_WORKING_BUFFER_SIZE);
|
|
break;
|
|
}
|
|
|
|
/* Read the pixels. Note that the bmp image is upside down */
|
|
if (rtgui_filerw_seek(bmp->filerw, bmp->pixel_offset, RTGUI_FILE_SEEK_SET) < 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (bmp->bit_per_pixel == 1)
|
|
{
|
|
if (bmp->scale > 3)
|
|
{
|
|
scale1 = bmp->scale - 3;
|
|
scale2 = 3;
|
|
}
|
|
else
|
|
{
|
|
scale1 = 0;
|
|
scale2 = bmp->scale;
|
|
}
|
|
}
|
|
else if (bmp->bit_per_pixel == 4)
|
|
{
|
|
if (bmp->scale > 1)
|
|
{
|
|
scale1 = bmp->scale - 1;
|
|
scale2 = 1;
|
|
}
|
|
else
|
|
{
|
|
scale1 = 0;
|
|
scale2 = bmp->scale;
|
|
}
|
|
}
|
|
|
|
/* Process whole image */
|
|
y = 0;
|
|
while (y < image->h)
|
|
{
|
|
x = 0;
|
|
readIndex = 0;
|
|
skipLength= 0;
|
|
|
|
/* Process a line */
|
|
while (readIndex < bmp->pitch)
|
|
{
|
|
/* Put progress indicator */
|
|
rt_kprintf("\r%lu%%", y * 100UL / image->h);
|
|
|
|
/* Read data to buffer */
|
|
readLength = (BMP_WORKING_BUFFER_SIZE > (bmp->pitch - readIndex)) ? \
|
|
(bmp->pitch - readIndex) : BMP_WORKING_BUFFER_SIZE;
|
|
if (rtgui_filerw_read(bmp->filerw, (void *)wrkBuffer, 1, readLength) != readLength)
|
|
{
|
|
rt_kprintf("BMP err: read failed\n");
|
|
error = RT_TRUE;
|
|
break;
|
|
}
|
|
readIndex += readLength;
|
|
|
|
/* Process read buffer */
|
|
if (bmp->bit_per_pixel == 1)
|
|
{
|
|
rt_uint8_t j;
|
|
rtgui_color_t color;
|
|
|
|
for (loadIndex = skipLength; loadIndex < readLength; loadIndex += 1 << scale1)
|
|
{
|
|
for (j = 0; j < 8; j += 1 << scale2)
|
|
{
|
|
color = image->palette->colors[(wrkBuffer[loadIndex] & (1 << (7 - j))) >> (7 - j)];
|
|
rtgui_dc_draw_color_point(dc,
|
|
dst_rect->x1 + x++,
|
|
dst_rect->y1 + image->h - y,
|
|
color);
|
|
}
|
|
if (scale1 && (readLength % (1 << scale1)))
|
|
{
|
|
skipLength = (1 << scale1) - readLength % (1 << scale1);
|
|
}
|
|
}
|
|
}
|
|
else if (bmp->bit_per_pixel == 4)
|
|
{
|
|
rt_uint8_t j;
|
|
rtgui_color_t color;
|
|
|
|
for (loadIndex = skipLength; loadIndex < readLength; loadIndex += 1 << scale1)
|
|
{
|
|
for (j = 0; j < 8; j += 1 << (2 + scale2))
|
|
{
|
|
color = image->palette->colors[(wrkBuffer[loadIndex] & (0x0F << (4 - j))) >> (4 - j)];
|
|
rtgui_dc_draw_color_point(dc,
|
|
dst_rect->x1 + x++,
|
|
dst_rect->y1 + image->h - y,
|
|
color);
|
|
}
|
|
}
|
|
if (scale1 && (readLength % (1 << scale1)))
|
|
{
|
|
skipLength = (1 << scale1) - readLength % (1 << scale1);
|
|
}
|
|
}
|
|
else if (bmp->bit_per_pixel == 8)
|
|
{
|
|
rtgui_color_t color;
|
|
|
|
for (loadIndex = skipLength; loadIndex < readLength; loadIndex += 1 << bmp->scale)
|
|
{
|
|
color = image->palette->colors[wrkBuffer[loadIndex]];
|
|
rtgui_dc_draw_color_point(dc,
|
|
dst_rect->x1 + x++,
|
|
dst_rect->y1 + image->h - y,
|
|
color);
|
|
}
|
|
if (readLength % (1 << bmp->scale))
|
|
{
|
|
skipLength = (1 << bmp->scale) - readLength % (1 << bmp->scale);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rtgui_blit_line_func blit_line;
|
|
rt_uint8_t hw_bytePerPixel = hw_driver->bits_per_pixel / 8;
|
|
rt_uint8_t temp[4] = {0};
|
|
|
|
if (!hw_bytePerPixel)
|
|
{
|
|
hw_bytePerPixel = 1;
|
|
}
|
|
|
|
if (hw_driver->pixel_format == RTGRAPHIC_PIXEL_FORMAT_RGB565)
|
|
{
|
|
blit_line = rtgui_blit_line_get_inv(hw_bytePerPixel, bytePerPixel);
|
|
}
|
|
else
|
|
{
|
|
blit_line = rtgui_blit_line_get(hw_bytePerPixel, bytePerPixel);
|
|
}
|
|
|
|
for (loadIndex = skipLength;
|
|
loadIndex < readLength;
|
|
loadIndex += bytePerPixel << bmp->scale)
|
|
{
|
|
blit_line(temp, &wrkBuffer[loadIndex], bytePerPixel);
|
|
dc->engine->blit_line(dc,
|
|
dst_rect->x1 + x, dst_rect->x1 + x + 1,
|
|
dst_rect->y1 + image->h - y,
|
|
temp);
|
|
x++;
|
|
}
|
|
if (readLength % (1 << bmp->scale))
|
|
{
|
|
skipLength = (1 << bmp->scale) - readLength % (1 << bmp->scale);
|
|
}
|
|
}
|
|
}
|
|
if (error)
|
|
{
|
|
break;
|
|
}
|
|
y++;
|
|
|
|
/* Skip padding bytes */
|
|
if (bmp->pad)
|
|
{
|
|
if ( rtgui_filerw_seek(bmp->filerw, bmp->pad, RTGUI_FILE_SEEK_CUR) < 0)
|
|
{
|
|
error = RT_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Height scale down */
|
|
if (bmp->scale)
|
|
{
|
|
if (rtgui_filerw_seek(bmp->filerw, (bmp->pitch + bmp->pad) * ((1 << bmp->scale) - 1),
|
|
RTGUI_FILE_SEEK_CUR) < 0)
|
|
{
|
|
error = RT_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (error)
|
|
{
|
|
break;
|
|
}
|
|
/* Release memory */
|
|
rt_free(wrkBuffer);
|
|
// rt_kprintf("BMP: load to display\n");
|
|
}
|
|
else
|
|
{
|
|
rt_uint16_t x, y;
|
|
rt_uint8_t* ptr;
|
|
|
|
for (y = 0; y < h; y ++)
|
|
{
|
|
ptr = bmp->pixels + (y * imageWidth);
|
|
if (bmp->bit_per_pixel <= 8)
|
|
{
|
|
rtgui_color_t color;
|
|
|
|
/* Using palette */
|
|
for (x = 0; x < w; x ++)
|
|
{
|
|
color = image->palette->colors[*(ptr++)];
|
|
rtgui_dc_draw_color_point(dc,
|
|
dst_rect->x1 + x,
|
|
dst_rect->y1 + y,
|
|
color);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rtgui_blit_line_func blit_line;
|
|
rt_uint8_t hw_bytePerPixel = hw_driver->bits_per_pixel / 8;
|
|
rt_uint8_t temp[4] = {0};
|
|
|
|
if (!hw_bytePerPixel)
|
|
{
|
|
hw_bytePerPixel = 1;
|
|
}
|
|
|
|
if (hw_driver->pixel_format == RTGRAPHIC_PIXEL_FORMAT_RGB565)
|
|
{
|
|
blit_line = rtgui_blit_line_get_inv(hw_bytePerPixel, bytePerPixel);
|
|
}
|
|
else
|
|
{
|
|
blit_line = rtgui_blit_line_get(hw_bytePerPixel, bytePerPixel);
|
|
}
|
|
|
|
for (x = 0; x < w; x ++)
|
|
{
|
|
blit_line(temp, ptr, bytePerPixel);
|
|
ptr += bytePerPixel;
|
|
dc->engine->blit_line(dc,
|
|
dst_rect->x1 + x, dst_rect->x1 + x + 1,
|
|
dst_rect->y1 + y,
|
|
temp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// rt_kprintf("BMP: blit ok\n");
|
|
} while(0);
|
|
}
|
|
|
|
void rtgui_image_bmp_init()
|
|
{
|
|
/* register bmp on image system */
|
|
rtgui_image_register_engine(&rtgui_image_bmp_engine);
|
|
}
|
|
#endif
|