jpeg-9中关于read_JPEG_file的使用及通过framebuffer显示JPEG

#include 

/*
 * Include file for users of JPEG library.
 * You will need to have included system headers that define at least
 * the typedefs FILE and size_t before you can include jpeglib.h.
 * (stdio.h is sufficient on ANSI-conforming systems.)
 * You may also wish to include "jerror.h".
 */

#include "jpeglib.h"

/*
 *  is used for the optional error recovery mechanism shown in
 * the second part of the example.
 */

#include 



/******************** JPEG COMPRESSION SAMPLE INTERFACE *******************/

/* This half of the example shows how to feed data into the JPEG compressor.
 * We present a minimal version that does not worry about refinements such
 * as error recovery (the JPEG code will just exit() if it gets an error).
 */


/*
 * IMAGE DATA FORMATS:
 *
 * The standard input image format is a rectangular array of pixels, with
 * each pixel having the same number of "component" values (color channels).
 * Each pixel row is an array of JSAMPLEs (which typically are unsigned chars).
 * If you are working with color data, then the color values for each pixel
 * must be adjacent in the row; for example, R,G,B,R,G,B,R,G,B,... for 24-bit
 * RGB color.
 *
 * For this example, we'll assume that this data structure matches the way
 * our application has stored the image in memory, so we can just pass a
 * pointer to our image buffer.  In particular, let's say that the image is
 * RGB color and is described by:
 */

extern JSAMPLE * image_buffer;	/* Points to large array of R,G,B-order data */
extern int image_height;	/* Number of rows in image */
extern int image_width;		/* Number of columns in image */

GLOBAL(int)read_JPEG_file (char * filename)
{
    /* This struct contains the JPEG decompression parameters and pointers to
    * working space (which is allocated as needed by the JPEG library).
    */
    struct jpeg_decompress_struct cinfo;
    /* We use our private extension JPEG error handler.
    * Note that this struct must live as long as the main JPEG parameter
    * struct, to avoid dangling-pointer problems.
    */
    struct my_error_mgr jerr;
    /* More stuff */
    FILE * infile;
    /* source file */
    JSAMPARRAY buffer;
    /* Output row buffer */
    int row_stride;
    /* physical row width in output buffer */

    /* In this example we want to open the input file before doing anything else,
    * so that the setjmp() error recovery below can assume the file is open.
    * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
    * requires it in order to read binary files.
    */
    if ((infile = fopen(filename, "rb")) == NULL)
    {
        fprintf(stderr, "can't open %s\n", filename);
        return 0;
    }
    /* Step 1: allocate and initialize JPEG decompression object
    */
    /* We set up the normal JPEG error routines, then override error_exit.
    */
    cinfo.err = jpeg_std_error(&jerr.pub);
    jerr.pub.error_exit = my_error_exit;
    /* Establish the setjmp return context for my_error_exit to use.
    */
    if (setjmp(jerr.setjmp_buffer))
    {
    /* If we get here, the JPEG code has signaled an error.
    * We need to clean up the JPEG object, close the input file, and return.
    */
    jpeg_destroy_decompress(&cinfo);
    fclose(infile);
    return 0;
    }
    /* Now we can initialize the JPEG decompression object.
    */
    jpeg_create_decompress(&cinfo);
    /* Step 2: specify data source (eg, a file)
    */
    jpeg_stdio_src(&cinfo, infile);
    /* Step 3: read file parameters with jpeg_read_header()
    */
    (void) jpeg_read_header(&cinfo, TRUE);
    /* We can ignore the return value from jpeg_read_header since
    * (a) suspension is not possible with the stdio data source, and
    * (b) we passed TRUE to reject a tables-only JPEG file as an error.
    * See libjpeg.txt for more info.
    */
    /* Step 4: set parameters for decompression
    */
    /* In this example, we don't need to change any of the defaults set by
    * jpeg_read_header(), so we do nothing here.
    */
    /* Step 5: Start decompressor */
    (void) jpeg_start_decompress(&cinfo);
    /* We can ignore the return value since suspension is not possible
    * with the stdio data source.
    */
    /* We may need to do some setup of our own at this point before reading
    * the data. After jpeg_start_decompress() we have the correct scaled
    * output image dimensions available, as well as the output colormap
    * if we asked for color quantization.
    * In this example, we need to make an output work buffer of the right size.
    */
    /* JSAMPLEs per row in output buffer */
    row_stride = cinfo.output_width * cinfo.output_components;
    /* Make a one-row-high sample array that will go away when done with image
    */
    buffer = (*cinfo.mem->alloc_sarray) ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
    /* Step 6: while (scan lines remain to be read) */
    /* jpeg_read_scanlines(...); */
    /* Here we use the library's state variable cinfo.output_scanline as the
    * loop counter, so that we don't have to keep track ourselves.
    */
    while (cinfo.output_scanline < cinfo.output_height)
    {
    /* jpeg_read_scanlines expects an array of pointers to scanlines.
    * Here the array is only one element long, but you could ask for
    * more than one scanline at a time if that's more convenient.
    */
    (void) jpeg_read_scanlines(&cinfo, buffer, 1);
    /* Assume put_scanline_someplace wants a pointer and sample count. */
    put_scanline_someplace(buffer[0], row_stride); }
    /* Step 7: Finish decompression */
    (void) jpeg_finish_decompress(&cinfo);
    /* We can ignore the return value since suspension is not possible
    * with the stdio data source. */
    /* Step 8: Release JPEG decompression object */
    /* This is an important step since it will release a good deal of memory. */
    jpeg_destroy_decompress(&cinfo);
    /* After finish_decompress, we can close the input file.
    * Here we postpone it until after no more JPEG errors are possible,
    * so as to simplify the setjmp error logic above. (Actually, I don't
    * think that jpeg_destroy can do an error exit, but why assume anything...)
    */

    fclose(infile);
    /* At this point you may want to check to see whether any corrupt-data
    * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
    */
    /* And we're done! */
    return 1;
}

使用framebuffer演示jpeg格式图片。

程序如下：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include  

#define    FB_DEV  "/dev/fb0"
unsigned char  *fbmem;
unsigned int    screensize;
unsigned int    fb_width;
unsigned int    fb_height;
unsigned int    fb_depth;
unsigned int    x;
unsigned int    y;
/***************** function declaration ******************/
void            usage(char *msg);
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(void *fbmem, int width, int height,
int x, int y, int r, int g, int b);
unsigned char * display_jpeg(char * filename,int *w, int *h);
/************ function implementation ********************/
int main(int argc, char *argv[])
{
	int             fbdev;
	char           *fb_device;
	int w ,h,i,j;

	if (argc != 2) {
		usage("insuffient auguments");
		exit(-1);
	}
	
	if ((fb_device = getenv("FRAMEBUFFER")) == NULL)
		fb_device = FB_DEV;
	fbdev = fb_open(fb_device);

	fb_stat(fbdev, &fb_width, &fb_height, &fb_depth);
	
	screensize = fb_width * fb_height * fb_depth / 8;
	fbmem = fb_mmap(fbdev, screensize);
	
	unsigned char *imgbuf, r, g, b;
	imgbuf = display_jpeg(argv[1],&w,&h);
	printf(" %s: w = %d,h = %d",argv[1],w,h);
	
	for(j = 0; j < h; j++)
	{
		for( i = 0; i < w; i++)
		{
			r = imgbuf[i*3 + j*w*3];
			g = imgbuf[i*3 + j*w*3 + 1];
			b = imgbuf[i*3 + j*w*3 + 2];
			fb_pixel(fbmem,fb_width,fb_height,i,j,r,g,b);
		}
	}

	fb_munmap(fbmem, screensize);
	
	fb_close(fbdev);

	return (0);

}

unsigned char * display_jpeg(char * filename, int *w, int *h)
{
	struct jpeg_decompress_struct cinfo;
	struct jpeg_error_mgr jerr;
	FILE           *infile;
	unsigned char  *buffer;
	unsigned char *temp;
	
	if ((infile = fopen(filename, "rb")) == NULL) {
		fprintf(stderr, "open %s failed/n", filename);
		exit(-1);
	}
	
	cinfo.err = jpeg_std_error(&jerr);
	jpeg_create_decompress(&cinfo);
	
	jpeg_stdio_src(&cinfo, infile);
	
	jpeg_read_header(&cinfo, TRUE);
	
	jpeg_start_decompress(&cinfo);
	*w = cinfo.output_width;
	*h = cinfo.output_height;

	if ((cinfo.output_width > fb_width) ||
			(cinfo.output_height > fb_height)) {
		printf("too large JPEG file,cannot display/n");
		return (-1);
	}

	buffer = (unsigned char *) malloc(cinfo.output_width *
			cinfo.output_components * cinfo.output_height);
	temp = buffer;
	while (cinfo.output_scanline < cinfo.output_height) {
		jpeg_read_scanlines(&cinfo, &buffer, 1);
		buffer += cinfo.output_width * cinfo.output_components;
	}

	jpeg_finish_decompress(&cinfo);
	jpeg_destroy_decompress(&cinfo);

	return temp;
	
	fclose(infile);
}

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

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);

}

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);

}

int fb_munmap(void *start, size_t length)
{
	return (munmap(start, length));
}

int fb_close(int fd)
{
	return (close(fd));

}


int fb_pixel(void *fbmem, int width, int height,
		int x, int y, int r, int g, int b)
{
	if ((x > width) || (y > height))

		return (-1);

	unsigned char *dst = fbmem + y * 5504 + x * 4; //'5504'为个人PC机的bpp

	dst[0] = b;
	dst[1] = g;
	dst[2] = r;

	return (0);

}