h3600_backpaq_camera.c

pxa270下的摄像头mtd91111的驱动

       23 *((p32)*(from+2*row_width+2))+ \
       10 *((p32)*(from+3*row_width+1))) >> 8)

#define PB1_3 ((9 *((p32)*(from-row_width))+ \
       7 *((p32)*(from-row_width+2))+ \
       117 *((p32)*(from+row_width))+ \
       91 *((p32)*(from+row_width+2))+ \
       18 *((p32)*(from+3*row_width))+ \
       14 *((p32)*(from+3*row_width+2))) >> 8)

#define PR2_3 ((7 *((p32)*(from-1))+ \
       21 *((p32)*(from+1))+ \
       9 *((p32)*(from+2*row_width-1))+ \
       27 *((p32)*(from+2*row_width+1))) >> 6)

#define PG2_3 ((((p32)*(from-row_width+1))+ \
       10 *((p32)*(from))+ \
       ((p32)*(from+2))+ \
       5 *((p32)*(from+row_width-1))+ \
       28 *((p32)*(from+row_width+1))+ \
       15 *((p32)*(from+2*row_width))+ \
       2 *((p32)*(from+2*row_width+2))+ \
       2 *((p32)*(from+3*row_width+1))) >> 6)

#define PB2_3 ((3 *((p32)*(from-row_width))+ \
       ((p32)*(from-row_width+2))+ \
       39 *((p32)*(from+row_width))+ \
       13 *((p32)*(from+row_width+2))+ \
       6 *((p32)*(from+3*row_width))+ \
       2 *((p32)*(from+3*row_width+2))) >> 6)

#define PR3_3 ((49 *((p32)*(from))+ \
       63 *((p32)*(from+2))+ \
       63 *((p32)*(from+2*row_width))+ \
       81 *((p32)*(from+2*row_width+2))) >> 8)

#define PG3_3 ((((p32)*(from-row_width))+ \
       2 *((p32)*(from-row_width+2))+ \
       ((p32)*(from-1))+ \
       48 *((p32)*(from+1))+ \
       2 *((p32)*(from+3))+ \
       48 *((p32)*(from+row_width))+ \
       71 *((p32)*(from+row_width+2))+ \
       2 *((p32)*(from+2*row_width-1))+ \
       71 *((p32)*(from+2*row_width+1))+ \
       4 *((p32)*(from+2*row_width+3))+ \
       2 *((p32)*(from+3*row_width))+ \
       4 *((p32)*(from+3*row_width+2))) >> 8)

#define PB3_3 ((((p32)*(from-row_width-1))+ \
       13 *((p32)*(from-row_width+1))+ \
       2 *((p32)*(from-row_width+3))+ \
       13 *((p32)*(from+row_width-1))+ \
       169 *((p32)*(from+row_width+1))+ \
       26 *((p32)*(from+row_width+3))+ \
       2 *((p32)*(from+3*row_width-1))+ \
       26 *((p32)*(from+3*row_width+1))+ \
       4 *((p32)*(from+3*row_width+3))) >> 8)

#define PR4_3 ((77 *((p32)*(from))+ \
       35 *((p32)*(from+2))+ \
       99 *((p32)*(from+2*row_width))+ \
       45 *((p32)*(from+2*row_width+2))) >> 8)

#define PG4_3 ((3 *((p32)*(from-row_width))+ \
       3 *((p32)*(from-1))+ \
       48 *((p32)*(from+1))+ \
       94 *((p32)*(from+row_width))+ \
       25 *((p32)*(from+row_width+2))+ \
       6 *((p32)*(from+2*row_width-1))+ \
       71 *((p32)*(from+2*row_width+1))+ \
       6 *((p32)*(from+3*row_width))) >> 8)

#define PB4_3 ((3 *((p32)*(from-row_width-1))+ \
       13 *((p32)*(from-row_width+1))+ \
       39 *((p32)*(from+row_width-1))+ \
       169 *((p32)*(from+row_width+1))+ \
       6 *((p32)*(from+3*row_width-1))+ \
       26 *((p32)*(from+3*row_width+1))) >> 8)

#define PR0_4 ((143 *((p32)*(from))+ \
       33 *((p32)*(from+2))+ \
       65 *((p32)*(from+2*row_width))+ \
       15 *((p32)*(from+2*row_width+2))) >> 8)

#define PG0_4 ((15 *((p32)*(from-row_width))+ \
       15 *((p32)*(from-1))+ \
       66 *((p32)*(from+1))+ \
       130 *((p32)*(from+row_width))+ \
       15 *((p32)*(from+row_width+2))+ \
       15 *((p32)*(from+2*row_width+1))) >> 8)

#define PB0_4 ((15 *((p32)*(from-row_width-1))+ \
       33 *((p32)*(from-row_width+1))+ \
       65 *((p32)*(from+row_width-1))+ \
       143 *((p32)*(from+row_width+1))) >> 8)

#define PR1_4 ((22 *((p32)*(from-1))+ \
       143 *((p32)*(from+1))+ \
       11 *((p32)*(from+3))+ \
       10 *((p32)*(from+2*row_width-1))+ \
       65 *((p32)*(from+2*row_width+1))+ \
       5 *((p32)*(from+2*row_width+3))) >> 8)

#define PG1_4 ((15 *((p32)*(from-row_width+1))+ \
       49 *((p32)*(from))+ \
       32 *((p32)*(from+2))+ \
       10 *((p32)*(from+row_width-1))+ \
       130 *((p32)*(from+row_width+1))+ \
       5 *((p32)*(from+row_width+3))+ \
       10 *((p32)*(from+2*row_width))+ \
       5 *((p32)*(from+2*row_width+2))) >> 8)

#define PB1_4 ((27 *((p32)*(from-row_width))+ \
       21 *((p32)*(from-row_width+2))+ \
       117 *((p32)*(from+row_width))+ \
       91 *((p32)*(from+row_width+2))) >> 8)

#define PR2_4 ((11 *((p32)*(from-1))+ \
       33 *((p32)*(from+1))+ \
       5 *((p32)*(from+2*row_width-1))+ \
       15 *((p32)*(from+2*row_width+1))) >> 6)

#define PG2_4 ((3 *((p32)*(from-row_width+1))+ \
       20 *((p32)*(from))+ \
       3 *((p32)*(from+2))+ \
       5 *((p32)*(from+row_width-1))+ \
       28 *((p32)*(from+row_width+1))+ \
       5 *((p32)*(from+2*row_width))) >> 6)

#define PB2_4 ((9 *((p32)*(from-row_width))+ \
       3 *((p32)*(from-row_width+2))+ \
       39 *((p32)*(from+row_width))+ \
       13 *((p32)*(from+row_width+2))) >> 6)

#define PR3_4 ((77 *((p32)*(from))+ \
       99 *((p32)*(from+2))+ \
       35 *((p32)*(from+2*row_width))+ \
       45 *((p32)*(from+2*row_width+2))) >> 8)

#define PG3_4 ((3 *((p32)*(from-row_width))+ \
       6 *((p32)*(from-row_width+2))+ \
       3 *((p32)*(from-1))+ \
       94 *((p32)*(from+1))+ \
       6 *((p32)*(from+3))+ \
       48 *((p32)*(from+row_width))+ \
       71 *((p32)*(from+row_width+2))+ \
       25 *((p32)*(from+2*row_width+1))) >> 8)

#define PB3_4 ((3 *((p32)*(from-row_width-1))+ \
       39 *((p32)*(from-row_width+1))+ \
       6 *((p32)*(from-row_width+3))+ \
       13 *((p32)*(from+row_width-1))+ \
       169 *((p32)*(from+row_width+1))+ \
       26 *((p32)*(from+row_width+3))) >> 8)

#define PR4_4 ((121 *((p32)*(from))+ \
       55 *((p32)*(from+2))+ \
       55 *((p32)*(from+2*row_width))+ \
       25 *((p32)*(from+2*row_width+2))) >> 8)

#define PG4_4 ((9 *((p32)*(from-row_width))+ \
       9 *((p32)*(from-1))+ \
       94 *((p32)*(from+1))+ \
       94 *((p32)*(from+row_width))+ \
       25 *((p32)*(from+row_width+2))+ \
       25 *((p32)*(from+2*row_width+1))) >> 8)

#define PB4_4 ((9 *((p32)*(from-row_width-1))+ \
       39 *((p32)*(from-row_width+1))+ \
       39 *((p32)*(from+row_width-1))+ \
       169 *((p32)*(from+row_width+1))) >> 8)


//Offsets: 0 1 0 1 1 

#define DO_BIGP(x,y,flush,color) \
        DO_ ## color ## _PIXEL_ ## flush ##(PR ## x ## _ ## y, \
                                            PG ## x ## _ ## y, \
                                            PB ## x ## _ ## y )
      
#define DO_BIGPA(x,y,flush,color) \
        DO_ ## color ## _APIXEL_ ## flush ##(PR ## x ## _ ## y, \
                                            PG ## x ## _ ## y, \
                                            PB ## x ## _ ## y )
      
#define DO_BIGPB(x,y,flush,color) \
        DO_ ## color ## _BPIXEL_ ## flush ##(PR ## x ## _ ## y, \
                                            PG ## x ## _ ## y, \
                                            PB ## x ## _ ## y )
            
/* Offsets: 0 1 0 1 1  */

/* Uses:  from, source, source_row, row_width, 
          streaming, buf, temp_buf, temp_buf_size, 
	  rvalue, gvalue, bvalue, stored_value */

#define CIF_ROW(x,flush,color) \
    do { int i; \
	for ( i = 0 ; i < 35 ; i++ ) { \
		DO_BIGPA(1,x,flush,color); from++; \
		DO_BIGPB(2,x,flush,color); \
		DO_BIGPA(3,x,flush,color); from++; \
		DO_BIGPB(4,x,flush,color); from++; \
                DO_BIGPA(0,x,flush,color); \
		DO_BIGPB(1,x,flush,color); from++; \
		DO_BIGPA(2,x,flush,color); \
		DO_BIGPB(3,x,flush,color); from++; \
		DO_BIGPA(4,x,flush,color); from++; \
                DO_BIGPB(0,x,flush,color); \
        } \
        DO_BIGPA(1,x,flush,color); from++; \
	DO_BIGPB(2,x,flush,color); \
       } while (0)

#define QCIF_ROW(x,flush,color) \
    do { int i; \
	for ( i = 0 ; i < 17 ; i++ ) { /* Do 17 * 10 = 170 columns */ \
		DO_BIGPA(1,x,flush,color); from++; \
		DO_BIGPB(2,x,flush,color); \
		DO_BIGPA(3,x,flush,color); from++; \
		DO_BIGPB(4,x,flush,color); from++; \
                DO_BIGPA(0,x,flush,color); \
		DO_BIGPB(1,x,flush,color); from++; \
		DO_BIGPA(2,x,flush,color); \
		DO_BIGPB(3,x,flush,color); from++; \
		DO_BIGPA(4,x,flush,color); from++; \
                DO_BIGPB(0,x,flush,color); \
        } \
        DO_BIGPA(1,x,flush,color); from++; \
	DO_BIGPB(2,x,flush,color); \
	DO_BIGPA(3,x,flush,color); from++; \
	DO_BIGPB(4,x,flush,color); from++; \
        DO_BIGPA(0,x,flush,color); \
	DO_BIGPB(1,x,flush,color); from++; \
    } while (0)


#define WRITE_CIF_ROW(therow) \
int write_cif_row_ ## therow (  register unsigned char *from, \
                                register unsigned char *to,   \
		                int row_width,                \
		                int palette,                  \
		                int flipped )                 \
{                                                             \
	register p32 rvalue, gvalue, bvalue, stored_value;    \
        int byte_count = 0;                                   \
                                                              \
	switch ( palette ) {                                  \
	case VIDEO_PALETTE_RGB24:                             \
                byte_count = 352 * 3;                         \
		if ( flipped ) {                              \
         		to += byte_count;                     \
			CIF_ROW(therow,REVERSE,COLOR);        \
		} else {                                      \
			CIF_ROW(therow,FORWARD,COLOR);        \
                }                                             \
		break;                                        \
	case VIDEO_PALETTE_GREY:                              \
                byte_count = 352;                             \
		if ( flipped ) {                              \
			to += byte_count;                     \
			CIF_ROW(therow,REVERSE,GREY);         \
		} else {                                      \
			CIF_ROW(therow,FORWARD,GREY);         \
                }                                             \
		break;                                        \
	case VIDEO_PALETTE_YUV422:                            \
                byte_count = 352 * 2;                         \
		if ( flipped ) {                              \
			to += byte_count;                     \
			CIF_ROW(therow,REVERSE,YUV);          \
		} else {                                      \
			CIF_ROW(therow,FORWARD,YUV);          \
                }                                             \
		break;                                        \
	}                                                     \
        return byte_count;                                    \
}

WRITE_CIF_ROW(0)
WRITE_CIF_ROW(1)
WRITE_CIF_ROW(2)
WRITE_CIF_ROW(3)
WRITE_CIF_ROW(4)

#define WRITE_QCIF_ROW(therow) \
int write_qcif_row_ ## therow (  register unsigned char *from, \
                                register unsigned char *to,   \
		                int row_width,                \
		                int palette,                  \
		                int flipped )                 \
{                                                             \
	register p32 rvalue, gvalue, bvalue, stored_value;    \
        int byte_count = 0;                                   \
                                                              \
	switch ( palette ) {                                  \
	case VIDEO_PALETTE_RGB24:                             \
                byte_count = 176 * 3;                         \
		if ( flipped ) {                              \
         		to += byte_count;                     \
			QCIF_ROW(therow,REVERSE,COLOR);       \
		} else {                                      \
			QCIF_ROW(therow,FORWARD,COLOR);       \
                }                                             \
		break;                                        \
	case VIDEO_PALETTE_GREY:                              \
                byte_count = 176;                             \
		if ( flipped ) {                              \
			to += byte_count;                     \
			QCIF_ROW(therow,REVERSE,GREY);        \
		} else {                                      \
			QCIF_ROW(therow,FORWARD,GREY);        \
                }                                             \
		break;                                        \
	case VIDEO_PALETTE_YUV422:                            \
                byte_count = 176 * 2;                         \
		if ( flipped ) {                              \
			to += byte_count;                     \
			QCIF_ROW(therow,REVERSE,YUV);         \
		} else {                                      \
			QCIF_ROW(therow,FORWARD,YUV);         \
                }                                             \
		break;                                        \
	}                                                     \
        return byte_count;                                    \
}

WRITE_QCIF_ROW(0)
WRITE_QCIF_ROW(1)
WRITE_QCIF_ROW(2)
WRITE_QCIF_ROW(3)
WRITE_QCIF_ROW(4)

#define YUV_FLUSH_PIXELS_FORWARD \
    if (streaming) { \
        to += bytes_written; \
    } else { \
        __copy_to_user( buf, temp_buf, bytes_written ); \
        to = temp_buf; \
        buf += bytes_written; \
    } \
    result += bytes_written

#define YUV_FLUSH_PIXELS_REVERSE \
    if (streaming) { \
        to -= bytes_written; \
    } else { \
        __copy_to_user( buf, temp_buf, bytes_written ); \
        buf -= bytes_written; \
        to = temp_buf; \
    } \
    result += bytes_written

#define DO_CIF_ROW(x,flush) \
	from = source + source_row * row_width + 1; \
	bytes_written = write_cif_row_ ## x( from, to, row_width, palette, flipped ); \
	YUV_FLUSH_PIXELS_ ## flush

#define DO_QCIF_ROW(x,flush) \
	from = source + source_row * row_width + 1; \
	bytes_written = write_qcif_row_ ## x( from, to, row_width, palette, flipped ); \
	YUV_FLUSH_PIXELS_ ## flush


#define WRITE_CIF_IMAGE(flush) \
	do {  	\
		int j;                                                      \
                int bytes_written;                                          \
                to = ( streaming ? buf : temp_buf );                        \
		for ( j = 0 ; j < 57 ; j++ ) {  /* Do 5 * 57 = 285 rows */  \
			source_row++;    DO_CIF_ROW(1,flush); \
			source_row += 2; DO_CIF_ROW(2,flush); \
			source_row++;    DO_CIF_ROW(3,flush); \
			source_row += 2; DO_CIF_ROW(4,flush); \
			source_row += 2; DO_CIF_ROW(0,flush); \
		} \
		source_row++;    DO_CIF_ROW(1,flush); \
		source_row += 2; DO_CIF_ROW(2,flush); \
		source_row++;    DO_CIF_ROW(3,flush); \
	} while (0)

#define WRITE_QCIF_IMAGE(flush) \
	do {  	\
		int j, bytes_written;  \
                to = ( streaming ? buf : temp_buf ); \
		for ( j = 0 ; j < 28 ; j++ ) { \
			source_row++;    DO_QCIF_ROW(1,flush); \
			source_row += 2; DO_QCIF_ROW(2,flush); \
			source_row++;    DO_QCIF_ROW(3,flush); \
			source_row += 2; DO_QCIF_ROW(4,flush); \
			source_row += 2; DO_QCIF_ROW(0,flush); \
		} \
		source_row++;    DO_QCIF_ROW(1,flush); \
		source_row += 2; DO_QCIF_ROW(2,flush); \
		source_row++;    DO_QCIF_ROW(3,flush); \
		source_row += 2; DO_QCIF_ROW(4,flush); \
	} while (0)

static unsigned long write_cif( struct frame *frame, unsigned char *buf, 
				int streaming, int flipped, int palette )
{
	unsigned char *source    = frame->data;
	register int row_width   = frame->width;

	unsigned char temp_buf[352 * 3];
	register unsigned char *to;
	register unsigned char *from;
	unsigned long           result = 0;
	int                     source_row = 0;

	if ( flipped ) {
		switch (palette) {
		case VIDEO_PALETTE_RGB24:
			buf += 352 * (288 - 1) * 3;
			break;