h3600_backpaq_camera.c

pxa270下的摄像头mtd91111的驱动

	if (!cam->frame_buf)
		return -ENOBUFS;

	for (i = 0; i < NUMBER_OF_FRAMES; i++)
		cam->frame[i].shared_data = cam->frame_buf + i * HC_MAX_PROCESSED_FRAME_SIZE;

	return 0;
}

static int free_frame_buf(struct h3600_camera_struct *cam)
{
	int i;
	
	rvfree(cam->frame_buf, NUMBER_OF_FRAMES * HC_MAX_PROCESSED_FRAME_SIZE);
	cam->frame_buf = 0;
	for (i=0; i < NUMBER_OF_FRAMES; i++)
		cam->frame[i].data = NULL;

	return 0;
}


/**********************************************************************
 *
 * Image Processing
 *
 **********************************************************************/

/* 
   Decimate in place, assuming a standard Bayer pattern starting at 0,0
   The subsampled image starts at offset x,y.
   We update "columns" and "rows" to return the new number of columns 
   and rows in the image.

   Bayer pattern is assumed to be:

       R G 
       G B

   starting at the top left corner.
   "Width" and "Height" should be multiples of two with x + width <= *columns, etc.

   We make _tons_ of assumptions

   Assumptions
   1. Error checking of bounds has been done.
   2. Width and height are multiples of 4
*/

static void decimate( struct frame *frame )
{
	/* Pick results that make sense */
	int width  = (frame->width / 2) & 0xfffc;
	int height = (frame->height / 2) & 0xfffc;

	unsigned char *p    = frame->data;   /* We'll store data at here */
	unsigned char *colp = frame->data;

	unsigned char *q;   /* We'll read data from here */
	int onecol = frame->width;
	int twocol = frame->width * 2;
	int i,j;

	for ( j = 0 ; j < height ; j+= 2) {
		q = colp;
		for ( i = 0 ; i < width ; i+=2 ) {
			/* Do red */
			*p++ = (((unsigned short) *q) * 2 
				+ (unsigned short) *(q + 2) 
				+ (unsigned short) *(q + twocol)) / 4;
			q+=2;
			/* Do green */
			*p++ = (((unsigned short) *(q + 1)
				 + (unsigned short) *(q + onecol)) / 2 );
			q+=2;
		}
		colp += twocol;
		q = colp;
		for ( i = 0 ; i < width ; i+=2 ) {
			/* Do green */
			*p++ = (((unsigned short) *(q + 1)
				 + (unsigned short) *(q + onecol)) / 2 );
			q+=2;
			/* Do blue */
			*p++ = (((unsigned short) *(q + onecol + 1)) * 2 
				+ (unsigned short) *(q + onecol - 1) 
				+ (unsigned short) *(q - onecol + 1)) / 4;
			q+=2;
		}
		colp += twocol;
	}
	frame->width = width;
	frame->height = height;
}


/******************************************************************************
 *
 * Processing macros
 *
 *   The Bayer pattern on the screen of the SMaL camera requires some
 *   special calculations to extract RGB values.  The core pattern
 *   looks like:
 * 
 *           R G R G
 *           G B G B
 *           R G R G
 *           G B G B
 *
 *   We can estimate the values of the colors at each of the 16 possible
 *   positions (4 inner locations, 4 corners, and 8 edge positions.
 * 
 *   The RGB values at each of these locations are stored in macros named
 *   "X##" in the following pattern (where X can be R,G, or B):
 *
 *           X11 X12 X13 X14
 *           X21 X22 X23 X24
 *           X31 X32 X33 X34
 *           X41 X42 X43 X44
 *
 ******************************************************************************/

/* Uses "from", "width" */

#define p32 int

#define PVAL       ((p32)*from)
#define PVAL1(a)   ((p32)*(from+a))
#define PVAL2(a,b) ((((p32)*(from+a)) + ((p32)*(from+b))) >> 1)

#define PVALUE(a1,a2,a3,b1,b2,b3,c1,c2,c3) \
  (( \
    a1 * ((p32)*(from-row_width-1)) + \
    a2 * ((p32)*(from-row_width)) +   \
    a3 * ((p32)*(from-row_width+1)) + \
    b1 * ((p32)*(from-1)) +       \
    b2 * ((p32)*(from)) +         \
    b3 * ((p32)*(from+1)) +       \
    c1 * ((p32)*(from+row_width-1)) + \
    c2 * ((p32)*(from+row_width)) +   \
    c3 * ((p32)*(from+row_width+1))   \
  ) / (a1 + a2 + a3 + b1 + b2 + b3 + c1 + c2 + c3 ))


#define R11 PVAL
#define G11 PVAL2(1,row_width)
#define B11 PVAL1(row_width+1)

#define R12 PVAL2(-1,1)
#define G12 PVAL
#define B12 PVAL1(row_width)

#define R13 PVAL
#define G13 PVALUE(0,0,0, 1,0,1, 0,2,0)
#define B13 PVAL2(row_width-1,row_width+1)

#define R14 PVAL1(-1)
#define G14 PVAL
#define B14 PVAL1(row_width)

#define R21 PVAL2(-row_width,row_width)
#define G21 PVAL
#define B21 PVAL1(1)

#define R22 PVALUE(1,0,1, 0,0,0, 1,0,1)
#define G22 PVALUE(0,1,0, 0,0,0, 0,1,0)
#define B22 PVAL

#define R23 PVAL2(-row_width,row_width)
#define G23 PVAL
#define B23 PVAL2(-1,1)

#define R24 PVAL2(-row_width-1,row_width-1)
#define G24 PVALUE(0,1,0, 2,0,0, 0,1,0)
#define B24 PVAL

#define R31 PVAL
#define G31 PVALUE(0,1,0, 0,0,2, 0,1,0)
#define B31 PVAL2(-row_width+1,row_width+1)

#define R32 PVAL2(-1,1)
#define G32 PVAL
#define B32 PVAL2(-row_width,row_width)

#define R33 PVAL
#define G33 PVALUE(0,1,0, 1,0,1, 0,1,0)
#define B33 PVALUE(1,0,1, 0,0,0, 1,0,1)

#define R34 PVAL1(-1)
#define G34 PVAL
#define B34 PVAL2(-row_width,row_width)

#define R41 PVAL1(-row_width)
#define G41 PVAL
#define B41 PVAL1(1)

#define R42 PVAL2(-row_width-1,-row_width+1)
#define G42 PVALUE(0,2,0, 1,0,1, 0,0,0)
#define B42 PVAL

#define R43 PVAL1(-row_width)
#define G43 PVAL
#define B43 PVAL2(-1,1)

#define R44 PVAL1(-row_width-1)
#define G44 PVAL2(-row_width,-1)
#define B44 PVAL

/* See "Video Demystified, pg 16, third edition */
#define FLOAT_SCALE_FACTOR   16
#define FLOAT_SCALE_VALUE   (1<<FLOAT_SCALE_FACTOR)
#define MAKE_FLOAT(x) ((p32)(x * FLOAT_SCALE_VALUE + 0.5))

#define R_TO_GREY  MAKE_FLOAT(0.299)
#define G_TO_GREY  MAKE_FLOAT(0.587)
#define B_TO_GREY  MAKE_FLOAT(0.114)

#define R_TO_Y     MAKE_FLOAT(0.257)
#define G_TO_Y     MAKE_FLOAT(0.504)
#define B_TO_Y     MAKE_FLOAT(0.098)
#define Y_OFFSET   16

#define R_TO_Cb    MAKE_FLOAT(-.148)
#define G_TO_Cb    MAKE_FLOAT(-.291)
#define B_TO_Cb    MAKE_FLOAT(0.439)
#define Cb_OFFSET  128

#define R_TO_Cr    MAKE_FLOAT(0.439)
#define G_TO_Cr    MAKE_FLOAT(-.368)
#define B_TO_Cr    MAKE_FLOAT(-.071)
#define Cr_OFFSET  128

#define GREY_VALUE(red,green,blue) \
     (((R_TO_GREY * red) + (G_TO_GREY * green) + (B_TO_GREY * blue)) >> FLOAT_SCALE_FACTOR)

/* pg. 18 - conversion of saturated RGB to YCbCr for SDTV */

#define Y_VALUE(red,green,blue) \
     ((((R_TO_Y * red) + (G_TO_Y * green) + (B_TO_Y * blue)) >> FLOAT_SCALE_FACTOR) + Y_OFFSET)

#define Cb_VALUE(red,green,blue) \
     ((((R_TO_Cb * red) + (G_TO_Cb * green) + (B_TO_Cb * blue)) >> FLOAT_SCALE_FACTOR)  + Cb_OFFSET)

#define Cr_VALUE(red,green,blue) \
     ((((R_TO_Cr * red) + (G_TO_Cr * green) + (B_TO_Cr * blue)) >> FLOAT_SCALE_FACTOR) + Cr_OFFSET)

/* 
   Uses:  to, from
*/

#define DO_GREY_PIXEL_FORWARD(red,green,blue) \
   *to++ = GREY_VALUE(red,green,blue); from++

#define DO_GREY_APIXEL_FORWARD(red,green,blue) DO_GREY_PIXEL_FORWARD(red,green,blue)
#define DO_GREY_BPIXEL_FORWARD(red,green,blue) DO_GREY_PIXEL_FORWARD(red,green,blue)

#define DO_GREY_PIXEL_REVERSE(red,green,blue) \
   *--to = GREY_VALUE(red,green,blue); from++

#define DO_GREY_APIXEL_REVERSE(red,green,blue) DO_GREY_PIXEL_REVERSE(red,green,blue)
#define DO_GREY_BPIXEL_REVERSE(red,green,blue) DO_GREY_PIXEL_REVERSE(red,green,blue)

#define DO_COLOR_PIXEL_FORWARD(red,green,blue) \
   *to++ = red; *to++ = green; *to++ = blue; from++

#define DO_COLOR_APIXEL_FORWARD(red,green,blue) DO_COLOR_PIXEL_FORWARD(red,green,blue)
#define DO_COLOR_BPIXEL_FORWARD(red,green,blue) DO_COLOR_PIXEL_FORWARD(red,green,blue)

#define DO_COLOR_PIXEL_REVERSE(red,green,blue) \
   *--to = blue; *--to = green; *--to = red; from++

#define DO_COLOR_APIXEL_REVERSE(red,green,blue) DO_COLOR_PIXEL_REVERSE(red,green,blue)
#define DO_COLOR_BPIXEL_REVERSE(red,green,blue) DO_COLOR_PIXEL_REVERSE(red,green,blue)

/* 
   Uses:  to, from, rvalue, gvalue, bvalue, stored_value
*/

#define DO_YUV_APIXEL_FORWARD(red,green,blue) \
    rvalue = red; \
    gvalue = green;  \
    bvalue = blue;  \
   *to++ = Y_VALUE(rvalue, gvalue, bvalue );    \
   *to++ = Cb_VALUE(rvalue, gvalue, bvalue );   \
    stored_value = Cr_VALUE(rvalue, gvalue, bvalue ); \
    from++

#define DO_YUV_BPIXEL_FORWARD(red,green,blue) \
   *to++ = Y_VALUE(red,green,blue); \
   *to++ = stored_value; \
    from++

#define DO_YUV_APIXEL_REVERSE(red,green,blue) \
    rvalue = red; \
    gvalue = green;  \
    bvalue = blue;  \
   *--to = Cr_VALUE(rvalue, gvalue, bvalue );   \
   *--to = Y_VALUE(rvalue, gvalue, bvalue );    \
    stored_value = Cb_VALUE(rvalue, gvalue, bvalue ); \
    from++

#define DO_YUV_BPIXEL_REVERSE(red,green,blue) \
   *--to = stored_value; \
   *--to = Y_VALUE(red,green,blue); \
    from++
    
/* 
   Uses:  streaming, buf, temp_buf, temp_buf_size, to, result 
*/

#define DO_FLUSH_PIXELS_FORWARD \
    if (!streaming) { __copy_to_user( buf, temp_buf, temp_buf_size ); to = temp_buf;}    \
    buf += temp_buf_size; \
    result += temp_buf_size

#define DO_FLUSH_PIXELS_REVERSE \
    buf -= temp_buf_size; \
    if (!streaming) { __copy_to_user( buf, temp_buf, temp_buf_size ); to = temp_buf + temp_buf_size;}    \
    result += temp_buf_size

#define DO_P(value,flush,color) \
        DO_ ## color ## _PIXEL_ ## flush ##(R ## value, G ## value, B ## value)
      
#define DO_PA(value,flush,color) \
        DO_ ## color ## _APIXEL_ ## flush ##(R ## value, G ## value, B ## value)
      
#define DO_PB(value,flush,color) \
        DO_ ## color ## _BPIXEL_ ## flush ##(R ## value, G ## value, B ## value)
      
#define WRITE_QVGA_IMAGE(flush,color) \
        do { int i,j;                                            \
	DO_PA(11,flush,color);                                    \
	for ( i = 1 ; i < width - 1 ; i+=2 ) {	                 \
                DO_PB(12,flush,color);	                         \
                DO_PA(13,flush,color); 	                         \
        }                                                        \
	DO_PB(14,flush,color);	                                 \
	DO_FLUSH_PIXELS_ ## flush;                               \
	for ( j = 1 ; j < height - 1 ; j += 2 ) {                \
		DO_PA(21,flush,color);	                         \
		for ( i = 1 ; i < width - 1 ; i+= 2 ) {	         \
                        DO_PB(22,flush,color);                    \
                        DO_PA(23,flush,color);                    \
         	}                                                \
		DO_PB(24,flush,color);	                         \
                DO_FLUSH_PIXELS_ ## flush;                       \
		DO_PA(31,flush,color);                            \
		for ( i = 1 ; i < width - 1 ; i+= 2 ) {          \
 	                DO_PB(32,flush,color);                    \
                	DO_PA(33,flush,color);	                 \
                }                                                \
		DO_PB(34,flush,color);                            \
		DO_FLUSH_PIXELS_ ## flush;                       \
	}                                                        \
	DO_PA(41,flush,color);                                    \
	for ( i = 1 ; i < width - 1 ; i+= 2 ) {                  \
        	DO_PB(42,flush,color);	                         \
                DO_PA(43,flush,color);	                         \
        }                                                        \
	DO_PB(44,flush,color);                                    \
	DO_FLUSH_PIXELS_ ## flush; } while(0)

#define WRITE_VGA_IMAGE(flush,color) \
	do {  	int i, j;                                        \
		for ( j = 0 ; j < height ; ) {                   \
			from = source + (++j) * row_width + 1;   \
			for ( i = 0 ; i < width ; i += 2 ) {     \
                                DO_PA(22,flush,color);            \
                                DO_PB(23,flush,color);            \
                        }                                        \
			DO_FLUSH_PIXELS_ ## flush;               \
			from = source + (++j) * row_width + 1;   \
			for ( i = 0 ; i < width ; i += 2 ) {     \
                                DO_PA(32,flush,color);            \
                                DO_PB(33,flush,color);            \
                        }                                        \
			DO_FLUSH_PIXELS_ ## flush;               \
		}                                                \
	} while (0)


/*********************************************/

static unsigned long write_qvga( struct frame *frame, unsigned char *buf, 
				 int streaming, int flipped, int palette )
{
	register unsigned char *from = frame->data;
	int width                    = frame->width;
	int height                   = frame->height;
	register int row_width       = width;
	unsigned char temp_buf[960];  /* 320 * 3 */
	register unsigned char *to;
	unsigned long           result = 0;
	int                     temp_buf_size;
	register p32            rvalue, gvalue, bvalue, stored_value;
	
	switch (palette) {
	case VIDEO_PALETTE_RGB24:
		temp_buf_size = width * 3;
		if ( !flipped ) {
			to = (streaming ? buf : temp_buf );
			WRITE_QVGA_IMAGE(FORWARD,COLOR);
		}
		else {
			buf += width * height * 3;
			to = (streaming ? buf : temp_buf + temp_buf_size );
			WRITE_QVGA_IMAGE(REVERSE,COLOR);
		}
		break;
	case VIDEO_PALETTE_GREY:
		temp_buf_size = width;
		if ( !flipped ) {
			to = (streaming ? buf : temp_buf );
			WRITE_QVGA_IMAGE(FORWARD,GREY);
		}
		else {