rtt-f030/components/rtgui/common/image_bmp.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);
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);
static struct rtgui_image* rtgui_image_bmp_zoom(struct rtgui_image* image, 
												float scalew, float scaleh, rt_uint32_t mode);
static struct rtgui_image* rtgui_image_bmp_rotate(struct rtgui_image* image, float angle);

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,
	rtgui_image_bmp_zoom,
	rtgui_image_bmp_rotate
};

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 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)
{
    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;
        }
        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 = (rt_uint16_t)bmp->w >> bmp->scale;
        image->h = (rt_uint16_t)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 > ((rt_uint16_t)bmp->pitch - readIndex)) ? \
                                 ((rt_uint16_t)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 */
        rtgui_free(wrkBuffer);
        return RT_TRUE;
    }
    while (0);

    /* Release memory */
    rtgui_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;
            rt_uint16_t y_start = dst_rect->y1 + h - 1;

            /* 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;
            }
            /* the image is upside down. So we need to start from middle if the
             * image is higher than the dst_rect. */
            if (image->h > rtgui_rect_height(*dst_rect))
            {
                int hdelta = image->h - rtgui_rect_height(*dst_rect);
                if (rtgui_filerw_seek(bmp->filerw, hdelta * (bmp->pitch + bmp->pad) * (1 << bmp->scale),
                            RTGUI_FILE_SEEK_CUR) < 0)
                {
                    error = RT_TRUE;
                    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;
                }
            }

            wrkBuffer = (rt_uint8_t *)rtgui_malloc(
					(BMP_WORKING_BUFFER_SIZE > bmp->pitch) ? \
					bmp->pitch : BMP_WORKING_BUFFER_SIZE);
            if (wrkBuffer == RT_NULL)
            {
                rt_kprintf("BMP err: no mem (%d)\n", BMP_WORKING_BUFFER_SIZE);
                break;
            }

            /* Process whole image */
            y = 0;
            while (y < h)
            {
                x = 0;
                readIndex = 0;
                skipLength = 0;

                /* Process a line */
                while (readIndex < bmp->pitch)
                {
                    /* Put progress indicator */
                    rt_kprintf("\r%lu%%", y * 100UL / h);

                    /* Read data to buffer */
                    readLength = (BMP_WORKING_BUFFER_SIZE > ((rt_uint16_t)bmp->pitch - readIndex)) ? \
                                 ((rt_uint16_t)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)
                    {
                        for (loadIndex = skipLength; loadIndex < readLength; loadIndex += 1 << scale1)
                        {
                            rt_uint8_t j;
                            for (j = 0; j < 8; j += 1 << scale2)
                            {
                                rtgui_color_t color;
                                color = image->palette->colors[(wrkBuffer[loadIndex] & (1 << (7 - j))) >> (7 - j)];
                                rtgui_dc_draw_color_point(dc,
                                                          dst_rect->x1 + x++,
                                                          y_start - y,
                                                          color);
                                if (x >= w)
                                    break;
                            }
                            if (scale1 && (readLength % (1 << scale1)))
                            {
                                skipLength = (1 << scale1) - readLength % (1 << scale1);
                            }
                        }
                    }
                    else if (bmp->bit_per_pixel == 4)
                    {
                        for (loadIndex = skipLength; loadIndex < readLength; loadIndex += 1 << scale1)
                        {
                            rt_uint8_t j;
                            for (j = 0; j < 8; j += 1 << (2 + scale2))
                            {
                                rtgui_color_t color;
                                color = image->palette->colors[(wrkBuffer[loadIndex] & (0x0F << (4 - j))) >> (4 - j)];
                                rtgui_dc_draw_color_point(dc,
                                                          dst_rect->x1 + x++,
                                                          y_start - y,
                                                          color);
                                if (x >= w)
                                    break;
                            }
                        }
                        if (scale1 && (readLength % (1 << scale1)))
                        {
                            skipLength = (1 << scale1) - readLength % (1 << scale1);
                        }
                    }
                    else if (bmp->bit_per_pixel == 8)
                    {
                        for (loadIndex = skipLength; loadIndex < readLength; loadIndex += 1 << bmp->scale)
                        {
                            rtgui_color_t color;
                            color = image->palette->colors[wrkBuffer[loadIndex]];
                            rtgui_dc_draw_color_point(dc,
                                                      dst_rect->x1 + x++,
                                                      y_start - y,
                                                      color);
                            if (x >= w)
                                break;
                        }
                        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,
                                                  y_start - y,
                                                  temp);
                            x++;
                            if (x >= w)
                                break;
                        }
                        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 */
            rtgui_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);
}

/*
 * config bitmap header.
 */
void rtgui_image_bmp_header_cfg(struct rtgui_image_bmp_header *bhr, rt_int32_t w, rt_int32_t h, rt_uint16_t bits_per_pixel)
{
	int image_size = w * h * bits_per_pixel/8;
	int header_size = sizeof(struct rtgui_image_bmp_header);

	bhr->bfType = 0x4d42; /* BM */
	bhr->bfSize = header_size + image_size; /* data size */
	bhr->bfReserved1 = 0;
	bhr->bfReserved2 = 0;
	bhr->bfOffBits = header_size;

	bhr->biSize = 40; /* sizeof BITMAPINFOHEADER */
	bhr->biWidth = w;
	bhr->biHeight = h;
	bhr->biPlanes = 1;
	bhr->biBitCount = bits_per_pixel;
	bhr->biCompression = BI_BITFIELDS;
	bhr->biSizeImage = image_size;
	bhr->biXPelsPerMeter = 0;
	bhr->biYPelsPerMeter = 0;
	bhr->biClrUsed = 0;
	bhr->biClrImportant = 0;
	if(bhr->biBitCount == 16 && bhr->biCompression == BI_BITFIELDS)
	{
		bhr->bfSize += 12;
		bhr->bfOffBits += 12;
	}
}
#ifdef RTGUI_USING_DFS_FILERW
#define WRITE_CLUSTER_SIZE	2048
void bmp_align_write(struct rtgui_filerw *file, char *dest, char *src, rt_int32_t len, rt_int32_t *count)
{
	rt_int32_t len_bak = len;

	while(len)
	{
		if(*count >= WRITE_CLUSTER_SIZE)
		{
			rtgui_filerw_write(file, dest, WRITE_CLUSTER_SIZE, 1);
			*count = 0;
		}
		*(dest + *count) = *(src + (len_bak-len));
		len --;
		(*count) ++;
	}
}

/*
 * Grab screen and save as a BMP file
 * MACRO RGB_CONVERT_TO_BGR: If the pixel of colors is BGR mode, defined it.
 */
void screenshot(const char *filename)
{
	struct rtgui_filerw *file;
	int w, h, i, pitch;
	rt_uint16_t *src;
	rt_uint32_t mask;
	struct rtgui_image_bmp_header bhr;
	struct rtgui_graphic_driver *grp = hw_driver;
#ifdef RGB_CONVERT_TO_BGR
	int j;
	rt_uint16_t *line_buf;
	rt_uint16_t color, tmp;
#endif
	char *pixel_buf;
	rt_int32_t write_count=0;

	file = rtgui_filerw_create_file(filename, "wb");
	if(file == RT_NULL)
	{
		rt_kprintf("create file failed\n");
		return;
	}

	w = grp->width;
	h = grp->height;

	pitch = w * sizeof(rt_uint16_t);
#ifdef RGB_CONVERT_TO_BGR
	line_buf = rt_malloc(pitch);
	if(line_buf == RT_NULL)
	{
		rt_kprintf("no memory!\n");
		return;
	}
#endif
	pixel_buf = rt_malloc(WRITE_CLUSTER_SIZE);
	if(pixel_buf == RT_NULL)
	{
		rt_kprintf("no memory!\n");
#ifdef RGB_CONVERT_TO_BGR
		rt_free(line_buf);
#endif
		return;
	}

	rtgui_image_bmp_header_cfg(&bhr, w, h, grp->bits_per_pixel);

	bmp_align_write(file, pixel_buf, (char*)&bhr, 
		sizeof(struct rtgui_image_bmp_header), &write_count);

	if(bhr.biCompression == BI_BITFIELDS)
	{
		mask = 0xF800; /* Red Mask */
		bmp_align_write(file, pixel_buf, (char*)&mask, 4, &write_count);
		mask = 0x07E0; /* Green Mask */
		bmp_align_write(file, pixel_buf, (char*)&mask, 4, &write_count);
		mask = 0x001F; /* Blue Mask */
		bmp_align_write(file, pixel_buf, (char*)&mask, 4, &write_count);
	}
	rtgui_screen_lock(RT_WAITING_FOREVER);
	if(grp->framebuffer != RT_NULL)
	{
		src = (rt_uint16_t*)grp->framebuffer;
		src += w * h;
		for(i=0; i<h; i++)
		{
			src -= w;
#ifdef RGB_CONVERT_TO_BGR
			for(j=0; j<w; j++)
			{
				tmp = *(src + j);
				color  = (tmp & 0x001F)<<11;
				color += (tmp & 0x07E0);
				color += (tmp & 0xF800)>>11;

				*(line_buf + i) = color;
			}
			bmp_align_write(file, pixel_buf, (char*)line_buf, pitch, &write_count);
#else
			bmp_align_write(file, pixel_buf, (char*)src, pitch, &write_count);
#endif
		}
	}
	else
	{
		rtgui_color_t pixel_color;
		rt_uint16_t write_color;
		int x;
		for(i=h-1; i>=0; i--)
		{
			x = 0;
			if(i%10==0)rt_kprintf(">",i);
			while(x < w)
			{
				grp->ops->get_pixel(&pixel_color, x, i);
				write_color = rtgui_color_to_565p(pixel_color);
				bmp_align_write(file, pixel_buf, (char*)&write_color, 
					sizeof(rt_uint16_t), &write_count);
				x++;
			}
		}
	}
	/* write The tail of the last */
	if(write_count < WRITE_CLUSTER_SIZE)
		rtgui_filerw_write(file, pixel_buf, write_count, 1);
	rtgui_screen_unlock();
#ifdef RGB_CONVERT_TO_BGR
	rt_free(line_buf);
#endif
	rt_free(pixel_buf);
	rt_kprintf("bmp create succeed.\n");
	rtgui_filerw_close(file);
}
#ifdef RT_USING_FINSH
#include <finsh.h>
FINSH_FUNCTION_EXPORT(screenshot, usage: screenshot(filename));
#endif
#endif
/*
* image zoom in, zoom out interface
* Support 16/24 bits format image
*/
static struct rtgui_image* rtgui_image_bmp_zoom(struct rtgui_image* image, 
												float scalew, float scaleh, rt_uint32_t mode)  
{ 
	struct rtgui_image *d_img;
	struct rtgui_image_bmp *bmp, *d_bmp;
	int bitcount, nbytes, i, j;
	int sw, sh, dw, dh;
	int dest_buff_size;
	int src_line_size, dest_line_size;
	char *src_buf;
	char *des_buf;  

	bmp = (struct rtgui_image_bmp*)image->data;
	src_buf = bmp->pixels;
	sw = bmp->w;
	sh = bmp->h;
	bitcount = bmp->bit_per_pixel;
	if(bitcount != 16 && bitcount != 24)
	{
		rt_kprintf("Does not support %d bits format\n", bitcount);
		return RT_NULL;
	}
	nbytes = bitcount / 8;
	src_line_size = sw * nbytes;

	dw = (int)(sw / scalew);
	dh = (int)(sh / scaleh);

	d_img = rt_malloc(sizeof(struct rtgui_image));
	if(d_img == RT_NULL) 
	{
		rt_kprintf("Not enough memory allocation IMG!\n");	
		return RT_NULL;
	}
	d_img->w = dw;
	d_img->h = dh;
	d_img->engine = &rtgui_image_bmp_engine;
	d_img->palette = RT_NULL;

	/* config dest bmp data */
	dest_line_size = ((dw * bitcount + (bitcount-1)) / bitcount) * nbytes;
	dest_buff_size = dest_line_size * dh;
	d_bmp = rt_malloc(sizeof(struct rtgui_image_bmp));
	if(d_bmp == RT_NULL)
	{
		rt_free(d_img);	
		rt_kprintf("Not enough memory allocation BMP!\n");
		return RT_NULL;
	}

	d_bmp->w = dw;
	d_bmp->h = dh;
	d_bmp->bit_per_pixel = bitcount;
	d_bmp->pixel_offset = 54; /* insignificant parameter */
	d_bmp->filerw = RT_NULL;
	d_bmp->is_loaded = RT_TRUE; /* Don't want to loading */
	d_bmp->pitch = d_bmp->w * nbytes;
	d_bmp->pad = ((d_bmp->pitch % 4) ? (4 - (d_bmp->pitch%4)) : 0);
	d_bmp->scale = 0;
	d_bmp->pixels = rt_malloc(dest_buff_size);
	if(d_bmp->pixels == RT_NULL) 
	{
		rt_free(d_img);
		rt_free(d_bmp);
		rt_kprintf("Not enough memory allocation BMP data!\n");
		return RT_NULL;
	}
	des_buf = d_bmp->pixels;

	if (mode == RTGUI_IMG_ZOOM_NEAREST) 
	{ 
		for (i = 0; i < dh; i++) 
		{  
			int src_th = (int)(scaleh * i + 0.5); 
			for (j = 0; j < dw; j++) 
			{ 
				int src_tw = (int)(scalew * j + 0.5);                             
				rt_memcpy (&des_buf[i * dest_line_size] + j * nbytes,
					&src_buf[src_th * src_line_size] + src_tw * nbytes,
					nbytes);             
			} 
		}     
	} 
	else if (mode == RTGUI_IMG_ZOOM_BILINEAR)
	{ 
		/* 
		** known: (i,j), (i+1,j), (i,j+1), (i+1,j+1), u, v
		** float coord: (i+u, j+v)
		** f(i+u,j+v) = (1-u)(1-v)f(i,j) + (1-u)vf(i,j+1) + u(1-v)f(i+1,j) + uvf(i+1,j+1)
		*/
		for (i = 0; i < dh; i++) 
		{ 
			int y = (int)(scaleh * i);  
			float u = (float)(scaleh * i - y);
			unsigned char c1, c2, c3, c4;
			for (j = 0; j < dw; j++) 
			{ 
				int x = (int)(scalew * j);
				float v = (float)(scalew * j - x);
				if(bitcount == 16)
				{	/* Each color component is calculated separately */
					rt_uint32_t cc1,cc2,cc3,cc4;
					unsigned char r, g, b;
					cc1 = rtgui_color_from_565p(*(rt_uint16_t*)(src_buf + 
						src_line_size * y     + nbytes * x    ));
					cc2 = rtgui_color_from_565p(*(rt_uint16_t*)(src_buf + 
						src_line_size * y     + nbytes * (x+1)));
					cc3 = rtgui_color_from_565p(*(rt_uint16_t*)(src_buf + 
						src_line_size * (y+1) + nbytes * x    ));
					cc4 = rtgui_color_from_565p(*(rt_uint16_t*)(src_buf + 
						src_line_size * (y+1) + nbytes * (x+1)));

					r = (unsigned char)((1-u)*(1-v)*(float)RTGUI_RGB_R(cc1) + 
						(1-u)*v*(float)RTGUI_RGB_R(cc2) + u*(1-v)*(float)RTGUI_RGB_R(cc3) + 
						u*v*(float)RTGUI_RGB_R(cc4));
					g = (unsigned char)((1-u)*(1-v)*(float)RTGUI_RGB_G(cc1) + 
						(1-u)*v*(float)RTGUI_RGB_G(cc2) + u*(1-v)*(float)RTGUI_RGB_G(cc3) + 
						u*v*(float)RTGUI_RGB_G(cc4));
					b = (unsigned char)((1-u)*(1-v)*(float)RTGUI_RGB_B(cc1) + 
						(1-u)*v*(float)RTGUI_RGB_B(cc2) + u*(1-v)*(float)RTGUI_RGB_B(cc3) + 
						u*v*(float)RTGUI_RGB_B(cc4));
					
					*(rt_uint16_t*)(des_buf + i * dest_line_size + j * nbytes) = 
						rtgui_color_to_565p(RTGUI_RGB(r, g, b));
				}
				else if(bitcount == 24)
				{
					int k;
					for (k = 0; k < 3; k++) 
					{	/* 24 bits color is 3 bytes R:G:B */ 
						c1 = (src_buf[src_line_size * y     + nbytes * x     + k]);
						c2 = (src_buf[src_line_size * y     + nbytes * (x+1) + k]);
						c3 = (src_buf[src_line_size * (y+1) + nbytes * x     + k]);
						c4 = (src_buf[src_line_size * (y+1) + nbytes * (x+1) + k]);

						des_buf[i * dest_line_size + j * nbytes + k] = (unsigned char)
							((1-u)*(1-v)*(float)c1 + (1-u)*v*(float)c2 + u*(1-v)*(float)c3 + u*v*(float)c4);
					} 
				}
			} 
		} 
	}
	d_img->data = d_bmp;

	return d_img;
} 

#include <math.h>
#ifndef M_PI
#define M_PI    3.14159265358979323846
#endif

/*
* around a pos o, rotating pos p
*/
rt_inline rtgui_point_t _rotate_pos(rtgui_point_t o, rtgui_point_t p, float sina, float cosa)
{
	rtgui_point_t rp;
	float dx, dy;
	dx = p.x - o.x;
	dy = p.y - o.y;

	rp.x = (float)o.x + dx * cosa + dy * sina;
	rp.y = (float)o.y + dy * cosa - dx * sina;

	return rp;
}

/*
* image rotate interface, rotate direction: clockwise
* Support 16/24 bits format image
*/
static struct rtgui_image* rtgui_image_bmp_rotate(struct rtgui_image* image, float angle)
{
	float age, sina, cosa;
	rtgui_point_t o, p, cp;
	rtgui_rect_t rect;
	struct rtgui_image *d_img;
	struct rtgui_image_bmp *bmp, *d_bmp;
	int bitcount, nbytes, i, j;
	int sw, sh, dw, dh;
	int dest_buff_size;
	int src_line_size, dest_line_size;
	char *src_buf;
	char *des_buf;  
	/* rt_tick_t tick = rt_tick_get(); */

	bmp = (struct rtgui_image_bmp*)image->data;
	src_buf = bmp->pixels;
	sw = bmp->w;
	sh = bmp->h;
	bitcount = bmp->bit_per_pixel;
	if(bitcount != 16 && bitcount != 24)
	{
		rt_kprintf("Does not support %d bits format\n", bitcount);
		return RT_NULL;
	}
	nbytes = bitcount / 8;
	src_line_size = sw * nbytes;
	
	/* convert angle to radians */
	age = angle * M_PI / 180.0;
	sina = sin(age);
	cosa = cos(age);

	/* 
	** known: a, b, angle;
	** solve: aa = a*abs(cos(angle)) + b*abs(sin(angle));
	** solve: bb = b*abs(cos(angle)) + a*abs(sin(angle));
	*/   
	dw = (int)(sw * fabs(cosa) + sh * fabs(sina));
	dh = (int)(sh * fabs(cosa) + sw * fabs(sina));
	rect.x1 = rect.y1 = 0;
	rect.x2 = sw; rect.y2 = sh;

	d_img = rt_malloc(sizeof(struct rtgui_image));
	if(d_img == RT_NULL) 
	{
		rt_kprintf("Not enough memory allocation IMG!\n");	
		return RT_NULL;
	}
	d_img->w = dw;
	d_img->h = dh;
	d_img->engine = &rtgui_image_bmp_engine;
	d_img->palette = RT_NULL;

	/* config dest bmp data */
	dest_line_size = ((dw * bitcount + (bitcount-1)) / bitcount) * nbytes;
	dest_buff_size = dest_line_size * dh;
	d_bmp = rt_malloc(sizeof(struct rtgui_image_bmp));
	if(d_bmp == RT_NULL)
	{
		rt_free(d_img);	
		rt_kprintf("Not enough memory allocation BMP!\n");
		return RT_NULL;
	}

	d_bmp->w = dw;
	d_bmp->h = dh;
	d_bmp->bit_per_pixel = bitcount;
	d_bmp->pixel_offset = 54; /* insignificant parameter */
	d_bmp->filerw = RT_NULL;
	d_bmp->is_loaded = RT_TRUE; /* Don't want to loading */
	d_bmp->pitch = d_bmp->w * nbytes;
	d_bmp->pad = ((d_bmp->pitch % 4) ? (4 - (d_bmp->pitch%4)) : 0);
	d_bmp->scale = 0;
	d_bmp->pixels = rt_malloc(dest_buff_size);
	if(d_bmp->pixels == RT_NULL) 
	{
		rt_free(d_img);
		rt_free(d_bmp);
		rt_kprintf("Not enough memory allocation BMP data!\n");
		return RT_NULL;
	}
	des_buf = d_bmp->pixels;
	/* use white fill empty pixel */
	rt_memset(des_buf, 0xFF, dest_buff_size);
	
	o.x = dw>>1;
	o.y = dh>>1;
	if(bitcount == 16 || bitcount == 24)
	{
		for (i = 0; i < dh; i++) 
		{
			for (j = 0; j < dw; j++) 
			{
				p.x = j; p.y = i;
				cp = _rotate_pos(o, p, sina, cosa);
				cp.x -= (dw-sw)>>1;
				cp.y -= (dh-sh)>>1;
				if(rtgui_rect_contains_point(&rect, cp.x, cp.y) != RT_EOK)
					continue;
				rt_memcpy (&des_buf[dest_line_size * i] + nbytes * j,
					&src_buf[src_line_size * cp.y] + nbytes * cp.x, nbytes); 
			} 
		}
	}
	d_img->data = d_bmp;
	/* rt_kprintf("rotate use %d ticks\n", rt_tick_get()-tick); */
	return d_img;
}

void rtgui_image_bmp_init()
{
    /* register bmp on image system */
    rtgui_image_register_engine(&rtgui_image_bmp_engine);
}
#endif