在fb 下显示图片(16/24/32 位色深)

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <linux/fb.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <jpeglib.h>
#include <jerror.h>

#define        FB_DEV "/dev/fb0"
#define        PWHERE() printf("FILE:%s, FUN:%s,LINE:%d\n", __FILE__, __FUNCTION__, __LINE__)

static unsigned char *fbmem;
static unsigned int fb_width;
static unsigned int fb_height;
static unsigned int fb_depth;

/*
* declaration for framebuffer device
*/
static int fbdev;
static char *fb_device;
static unsigned int screensize;

/***************** function declaration ******************/
void            usage(char *msg);
unsigned short  RGB888toRGB565(unsigned char red,
                unsigned char green, unsigned char blue);
int fb_open(char *fb_device);
int fb_close(int fd);
int fb_stat(int fd, int *width, int *height, int *depth);
void *fb_mmap(int fd, unsigned int screensize);
int fb_munmap(void *start, size_t length);
int fb_pixel_32(void *fbmem, int width, int height,
                int x, int y, unsigned int color);
int fb_pixel_16(void *fbmem, int width, int height,
                int x, int y, unsigned short color);

/************ function implementation ********************/
void usage(char *msg)
{
    fprintf(stderr, "%s\n", msg);
    printf("Usage: fv some-jpeg-file.jpg\n");
}

/*
 * convert 24bit RGB888 to 16bit RGB565 color format
 */
unsigned short RGB888toRGB565(unsigned char red, unsigned char green, unsigned char blue)
{
    unsigned short  B = (blue >> 3) & 0x001F;
    unsigned short  G = ((green >> 2) << 5) & 0x07E0;
    unsigned short  R = ((red >> 3) << 11) & 0xF800;

    return (unsigned short) (R | G | B);
}
/*
 * convert 24bit RGB888 to 32bit RGB8888 color format
 */
unsigned int RGB888toRGB8888(unsigned char red, unsigned char green, unsigned char blue)
{
    unsigned int B = (blue) & 0x00000FF;
    unsigned int G = (green << 8) & 0x0000FF00;
    unsigned int R = (red << 16) & 0x00FF0000;
    unsigned int A = (255 << 24) & 0xFF000000;
    return (unsigned int ) (R | G | B |A);

}


/*
 * open framebuffer device.
 * return positive file descriptor if success,
 * else return -1.
 */
int fb_open(char *fb_device)
{
    int fd;

    if ((fd = open(fb_device, O_RDWR)) < 0) {
        perror(__func__);
        return (-1);
    }
    return (fd);
}

/*
 * get framebuffer's width,height,and depth.
 * return 0 if success, else return -1.
 */
int fb_stat(int fd, int *width, int *height, int *depth)
{
    struct fb_fix_screeninfo fb_finfo;
    struct fb_var_screeninfo fb_vinfo;

    if (ioctl(fd, FBIOGET_FSCREENINFO, &fb_finfo)) {
        perror(__func__);
        return (-1);
    }

    if (ioctl(fd, FBIOGET_VSCREENINFO, &fb_vinfo)) {
        perror(__func__);
        return (-1);
    }

    *width = fb_vinfo.xres;
    *height = fb_vinfo.yres;
    *depth = fb_vinfo.bits_per_pixel;

    return (0);
}

/*
 * map shared memory to framebuffer device.
 * return maped memory if success,
 * else return -1, as mmap dose.
 */
void *fb_mmap(int fd, unsigned int screensize)
{
    caddr_t         fbmem;

    if ((fbmem = mmap(0, screensize, PROT_READ | PROT_WRITE,
                    MAP_SHARED, fd, 0)) == MAP_FAILED) {
        perror(__func__);
        return (void *) (-1);
    }

    return (fbmem);
}

/*
 * unmap map memory for framebuffer device.
 */
int fb_munmap(void *start, size_t length)
{
    return (munmap(start, length));
}

/*
 * close framebuffer device
 */
int fb_close(int fd)
{
    return (close(fd));
}


void init_device (void)
{

    /*
     * open framebuffer device
     */
    if ((fb_device = getenv("FRAMEBUFFER")) == NULL)
        fb_device = FB_DEV;
    fbdev = fb_open(fb_device);
    if (fbdev < 0) {
        perror("open fb error");
        exit(-1);
    }

    /*
     * get status of framebuffer device
     */
    fb_stat(fbdev, &fb_width, &fb_height, &fb_depth);

    /*
     * map framebuffer device to shared memory
     */
    screensize = fb_width * fb_height * fb_depth / 8;
    fbmem = fb_mmap(fbdev, screensize);
}
/*
 * display a pixel on the framebuffer device.
 * fbmem is the starting memory of framebuffer,
 * width and height are dimension of framebuffer,
 * x and y are the coordinates to display,
 * color is the pixel's color value.
 * return 0 if success, otherwise return -1.
 */
int fb_pixel_32(void *fbmem, int width, int height,
            int x, int y, unsigned int color)
{
    if ((x > width) || (y > height))
        return (-1);

    unsigned int *dst = ((unsigned int *) fbmem + y * width + x);

    *dst = color;
    return 0;
}

int fb_pixel_16(void *fbmem, int width, int height,
            int x, int y, unsigned short color)
{
    if ((x > width) || (y > height))
        return (-1);

    unsigned short *dst = ((unsigned short *) fbmem + y * width + x);

    *dst = color;
    return 0;
}

void draw_chessboard_16(unsigned short color)
{
    unsigned int x,y;
    int step = 50;
    // draw  line  H  dirction step by 50
    for (y = step; y < fb_height - step; y += step) {
        for (x = 100; x < fb_width - step; x++) {
            fb_pixel_16(fbmem,fb_width, fb_height,x,y,color); //color(16bit):R(5) G(6) B(5)
                    //color(24bit):R(8) G(8) B(8)      //color(32bit):R(10) G(12) B(10)
        }
    }

    // draw  line  V  dirction step by 50
    for(x = 100; x < fb_width - step; x += step) {
        for(y = step; y < fb_height - step; y++) {
            fb_pixel_16(fbmem,fb_width, fb_height,x,y,color);
        }
    }

}

void draw_chessboard_32(unsigned int color)
{
    unsigned int x,y;
    int step = 50;
    // draw  line  H  dirction step by 50
    for (y = step; y < fb_height -step; y += step) {
        for (x = 100; x < fb_width -step; x++) {
            fb_pixel_32(fbmem,fb_width, fb_height,x,y,color); //color(16bit):R(5) G(6) B(5)
                    //color(24bit):R(8) G(8) B(8)      //color(32bit):R(10) G(12) B(10)
        }
    }

    // draw  line  V  dirction step by 50
    for(x = 100; x < fb_width - step; x += step) {
        for(y = step; y < fb_height -step; y++) {
            fb_pixel_32(fbmem,fb_width, fb_height,x,y,color);
        }
    }
}


FILE *open_pic(char *filename)
{
     /*
     * open input jpeg file
     */
    FILE *fp;
    if ((fp= fopen(filename, "rb")) == NULL) {
        fprintf(stderr, "open %s failed\n", filename);
        exit(-1);
    }

    return fp;
}

int close_pic(FILE *fp)
{    /*
     * close jpeg inputing file
     */

    return fclose(fp);
}

void display_pic(unsigned char *buffer, struct jpeg_decompress_struct cinfo)
{
    int x = 0,y = 0;
    unsigned short  color;
    unsigned int color_int;

    int pic_w = cinfo.output_width;
    int pic_h = cinfo.output_height;
    int pic_bytes = cinfo.output_components;

//    printf("w:%d, h:%d,bytes:%d\n", pic_w, pic_h, pic_bytes);

    int offset = 0;

    if (fb_depth == 16) {
        unsigned short color_buf[pic_w * pic_h];
        memset(color_buf, 0, sizeof(color_buf));

        if(pic_h == fb_height && pic_w == fb_width) {
            while (y < pic_h) {
                for (x = 0; x < pic_w; x++) {
                    color_buf[y*pic_w + x] = RGB888toRGB565(buffer[x * 3],
                                        buffer[x * 3 + 1], buffer[x * 3 + 2]);
                }
                y++;
                buffer += pic_w * pic_bytes;
            }

            memcpy((unsigned char*) fbmem, color_buf, sizeof(color_buf));
        } else {
            while (y < pic_h) {
                for (x = 0; x < pic_w; x++) {
                    color_buf[y*pic_w + x] = RGB888toRGB565(buffer[x * 3],
                                        buffer[x * 3 + 1], buffer[x * 3 + 2]);
                }
                offset = pic_w * y ;
                memcpy((unsigned char*) fbmem + y*fb_width*fb_depth/8,
                        color_buf + offset, pic_w*fb_depth/8);
                y++;
                buffer += pic_w * pic_bytes;
            }
        }
    } else if (fb_depth == 24) {
        if(pic_h == fb_height && pic_w == fb_width) {
            memcpy((unsigned char *) fbmem, buffer, pic_w * pic_h * pic_bytes);
        } else {
            while (y < pic_h) {
                memcpy((unsigned char*) fbmem + y*fb_width*fb_depth/8,
                        buffer, pic_w*fb_depth/8);
                y++;
                buffer += pic_w * fb_depth/8;
            }
        }
    } else if (fb_depth == 32) {
        unsigned int color_buf[pic_w * pic_h];
        memset(color_buf, 0, sizeof(color_buf));

        //当图片大小与分辨相同时，使用此方法显示更快
        if(pic_h == fb_height && pic_w == fb_width) {
            while (y < pic_h) {
                for (x = 0; x < pic_w; x ++) {
                    color_buf[y*pic_w + x] = RGB888toRGB8888(buffer[x * 3],
                                        buffer[x * 3 + 1], buffer[x * 3 + 2]);
                }
                y++;
                buffer += pic_w * pic_bytes;
            }

            memcpy((unsigned char*) fbmem, color_buf, sizeof(color_buf));

        } else {
            while (y < pic_h) {
                for (x = 0; x < pic_w; x ++) {
                    color_buf[y*pic_w + x] = RGB888toRGB8888(buffer[x * 3],
                                        buffer[x * 3 + 1], buffer[x * 3 + 2]);
                }
                offset = pic_w * y ;
                memcpy((unsigned char*) fbmem + y*fb_width*fb_depth/8,
                        color_buf + offset, pic_w*fb_depth/8);
                y++;
                buffer += pic_w * pic_bytes;
            }
        }
    }
}


int    decompress_display_pic(FILE *infile)
{
    /*
    * declaration for jpeg decompression
    */

    struct jpeg_decompress_struct cinfo;
    struct jpeg_error_mgr jerr;
    unsigned char *buffer;

    /*
     * init jpeg decompress object error handler
     */
    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_decompress(&cinfo);

    /*
     * bind jpeg decompress object to infile
     */
    jpeg_stdio_src(&cinfo, infile);

    /*
     * read jpeg header
     */
    jpeg_read_header(&cinfo, TRUE);

    /*
     * decompress process.
     * note: after jpeg_start_decompress() is called
     * the dimension infomation will be known,
     * so allocate memory buffer for scanline immediately
     */
    jpeg_start_decompress(&cinfo);
    if ((cinfo.output_width > fb_width) ||
        (cinfo.output_height > fb_height)) {
        printf("fb_width = %d,fb_height = %d\n",fb_width,fb_height);
        printf("cinfo.output_width = %d,cinfo.output_height = %d\n",cinfo.output_width,cinfo.output_height);
        printf("too large JPEG file,cannot display\n");
        return (-1);
    }

//    printf("cinfo.output_width = %d,cinfo.output_height = %d\n",cinfo.output_width,cinfo.output_height);
//    printf("output_components: %d\n", cinfo.output_components);
    int buffer_size = cinfo.output_width * cinfo.output_components;
    buffer = (unsigned char *) malloc(buffer_size);

    unsigned char *pic_buf = NULL;
    unsigned char *tmp_buf = NULL;
    int pic_size = cinfo.output_width * cinfo.output_height * cinfo.output_components;
    pic_buf = (unsigned char *) malloc(pic_size);
    tmp_buf = pic_buf;
    memset(buffer, 0, sizeof(buffer_size));
    memset(pic_buf, 0, sizeof(pic_size));

    while (cinfo.output_scanline < cinfo.output_height) {
        jpeg_read_scanlines(&cinfo, &buffer, 1);
        memcpy(tmp_buf, buffer, buffer_size);
        tmp_buf += buffer_size;
    }

    //display_pic(tmp_buf, pic_w, pic_h, pic_bytes);
    /*
     * finish decompress, destroy decompress object
     */
    jpeg_finish_decompress(&cinfo);
    jpeg_destroy_decompress(&cinfo);

    display_pic(pic_buf, cinfo);

    /*
     * release memory buffer
     */
    free(buffer);
    free(pic_buf);
    buffer = NULL;
    pic_buf = NULL;
}


void delay_s(unsigned int m)
{
    unsigned int i;
    unsigned long l;
    unsigned long n=60000000;

    for (i=0; i<m; i++)
        for(l=0; l<n; l++);
}


int main(int argc, char *argv[])
{
    //initzilation device
    init_device();
    printf("the max size:fb_width = %d,fb_height = %d, fb_depth = %d\n",fb_width,fb_height,fb_depth);

    /*
    * check auguments
    */
/*
    if (argc != 2){
            printf("the max size:fb_width = %d,fb_height = %d, fb_depth = %d\n",fb_width,fb_height,fb_depth);
            usage("insuffient auguments");
     exit(-1);
    }
*/
    //display a picture as the chess board background
    FILE *fp1 = NULL;
    FILE *fp2 = NULL;

    fp1 = open_pic("./3.jpg");
    fp2 = open_pic("./4.jpg");

    while (1) {
        decompress_display_pic(fp1);
        delay_s(1);
        decompress_display_pic(fp2);
        delay_s(1);
        rewind(fp1);
        rewind(fp2);
    }

    fclose(fp1);
    fclose(fp2);
    /*draw chess board*/
    /*
    if (fb_depth == 32)
        draw_chessboard_32(0x0000ff00);
    else if (fb_depth == 16)
        draw_chessboard_16(0xf800);
    */
    /*
     * unmap framebuffer's shared memory
     */
    fb_munmap(fbmem, screensize);

    /*
     * close framebuffer device
     */
    fb_close(fbdev);

    return (0);
}

makefile

CC = gcc -g

TARGET = testProg

OBJS = pic.o

all:$(TARGET)

$(TARGET):$(OBJS)
    $(CC) -o $@ $^ -ljpeg -lm

.PHONY:clean

clean:
    rm *.o $(TARGET) -f
cleanobj:
    rm *.o -f