cam2tft.c

This is the source code of Camera driver for OV2640 camera from OmniVision using in Blackfin platfor

/*
 *
 *    Rev:          $Id: ppifcd_test.c 6171 2008-02-04 10:42:30Z hennerich $
 *    Revision:     $Revision: 6171 $
 *    Source:       $Source$
 *    Created:      Do Apr 21 11:02:09 CEST 2005
 *    Author:       Michael Hennerich
 *    mail:         [e-mail]
 *    Description:  PPI frame capture driver test code
 *
 *   Copyright (C) 2005 Michael Hennerich
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 ****************************************************************************
 * MODIFICATION HISTORY:
 ***************************************************************************/

#include <sys/ioctl.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <linux/ioctl.h>
#include <errno.h>
#include <unistd.h>
#include <getopt.h>
#include <string.h>
#include <strings.h>
#include <sys/mman.h>
#include <linux/fb.h>
#include <setjmp.h>

#define debug

#ifdef TM_IN_SYS_TIME
#include <sys/time.h>
#else
#include <time.h>
#endif

#include "pflags.h"
#include "adsp-ppifcd.h"

#define I2C_DEVICE      "/dev/i2c-0"
#define PPI_DEVICE      "/dev/ppi"
#define VERSION         "0.1"

/****************************************************************************/
#define OV2640FSL
#define UXGA_WIDTH  1600
#define UXGA_HEIGHT 1200
#define SVGA_WIDTH  800
#define SVGA_HEIGHT 600
#define CIF_WIDTH   400
#define CIF_HEIGHT  292

#define MASTERCLOCK     48	//MHz

/****************************************************************************/
#ifdef OV2640FSL
#define DEVID           (0x60>>1)
#define CAM_REG_RESET 			0x12
#define CAM_MASK_RESET_BIT		(1 << 7)
#define WIDTH           UXGA_WIDTH
#define HEIGHT          UXGA_HEIGHT
#define VID_WIDTH       SVGA_WIDTH
#define VID_HEIGHT      SVGA_HEIGHT
#define TFT_WIDTH		320
#define TFT_HEIGHT		240
#endif
/****************************************************************************/

#define AVERAGE         100

extern int i2c_write_register(char *, unsigned char, unsigned char,
			      unsigned short);
extern int i2c_read_register(char *, unsigned char, unsigned char);
extern int i2c_dump_register(char *, unsigned char, unsigned short,
			     unsigned short);
extern int i2c_scan_bus(char *);

#define CAM_write_reg(x) i2c_write_register(I2C_DEVICE, DEVID, (x>>8)&0xFF, 0xFF & x)
#define CAM_read_reg(x) i2c_read_register(I2C_DEVICE, DEVID, 0xFF & x)

unsigned short *framebase;
int capture_width = WIDTH;
int capture_height = HEIGHT;
int video_width = VID_WIDTH;
int video_height = VID_HEIGHT;
int tft_width = TFT_WIDTH;
int tft_height = TFT_HEIGHT;
#define IMAGESIZE       (width * height)

/*
void ConvertRaw8ToRGB (unsigned char *RGBbuffer, unsigned char *RAW8buffer, int nXsize, int nYsize)
{
	unsigned char *Rplane = RGBbuffer+2;
	unsigned char *Gplane = RGBbuffer+1;
	unsigned char *Bplane = RGBbuffer;
	
	unsigned char nValue;
	
	int x,y;
	
	for (y = 0; y < nYsize; y++) {
		for (x = 0; x < nXsize; x++) {
			// Calculate Rplane
			if (y == 0)
				if (x == 0) {
					nValue = *(RAW8buffer+nXsize+1);
				} else if (x & 0x01) {
					nValue = *(RAW8buffer+nXsize);
				} else {
					nValue = (*(RAW8buffer+nXsize-1) + *(RAW8buffer+nXsize+1))/2;
				}
			else if (y & 0x01)
				if (x == 0) {
					nValue = *(RAW8buffer+1);
				} else if (x & 0x01) {
					nValue = *(RAW8buffer);
				} else {
					nValue = (*(RAW8buffer-1) + *(RAW8buffer+1))/2;
				}
			else
				if (x == 0) {
					nValue = (*(RAW8buffer-nXsize+1) + *(RAW8buffer+nXsize+1))/2;
				} else if (x & 0x01) {
					nValue = (*(RAW8buffer-nXsize) + *(RAW8buffer+nXsize))/2;
				} else {
					nValue = (*(RAW8buffer-nXsize-1) + *(RAW8buffer-nXsize+1)
							+ *(RAW8buffer+nXsize-1) + *(RAW8buffer+nXsize+1))/4;
				}
			*Rplane = nValue;

			// Calculate Gplane
			if (y == 0)
				if (x == 0) {
					nValue = (*(RAW8buffer+1) + *(RAW8buffer+nXsize))/2;
				} else if (x & 0x01) {
					nValue = *(RAW8buffer);
				} else {
					nValue = (*(RAW8buffer-1) + *(RAW8buffer+1) + *(RAW8buffer+nXsize))/3;
				}
			else if (y == nYsize-1)
				if (x == nXsize-1) {
					nValue = (*(RAW8buffer-nXsize) + *(RAW8buffer-1))/2;
				} else if (x & 0x01) {
					nValue = (*(RAW8buffer-1) + *(RAW8buffer+1) + *(RAW8buffer-nXsize))/3;
				} else {
					nValue = *(RAW8buffer);
				}
			else if (y & 0x01)
				if (x == nXsize-1) {
					nValue = (*(RAW8buffer-1) + *(RAW8buffer-nXsize) + *(RAW8buffer+nXsize))/3;
				} else if (x & 0x01) {
					nValue = (*(RAW8buffer-1) + *(RAW8buffer-nXsize)
							+ *(RAW8buffer+1) + *(RAW8buffer+nXsize))/4;
				} else {
					nValue = *(RAW8buffer);
				}
			else
				if (x == 0) {
					nValue = (*(RAW8buffer+1) + *(RAW8buffer-nXsize) + *(RAW8buffer+nXsize))/3;
				} else if (x & 0x01) {
					nValue = *(RAW8buffer);
				} else {
					nValue = (*(RAW8buffer-1) + *(RAW8buffer-nXsize)
							+ *(RAW8buffer+1) + *(RAW8buffer+nXsize))/4;
				}
			*Gplane = nValue;
			
			// Calculate Bplane
			if (y == nYsize-1)
				if (x == nXsize-1) {
					nValue = *(RAW8buffer-nXsize-1);
				} else if (x & 0x01) {
					nValue = (*(RAW8buffer-nXsize-1) + *(RAW8buffer-nXsize+1))/2;
				} else {
					nValue = *(RAW8buffer-nXsize);
				}
			else if (y & 0x01)
				if (x == nXsize-1) {
					nValue = (*(RAW8buffer-nXsize-1) + *(RAW8buffer+nXsize-1))/2;
				} else if (x & 0x01) {
					nValue = (*(RAW8buffer-nXsize-1) + *(RAW8buffer-nXsize+1)
							+ *(RAW8buffer+nXsize-1) + *(RAW8buffer+nXsize+1))/4;
				} else {
					nValue = (*(RAW8buffer-nXsize) + *(RAW8buffer+nXsize))/2;
				}
			else
				if (x == nXsize-1) {
					nValue = *(RAW8buffer-1);
				} else if (x & 0x01) {
					nValue = (*(RAW8buffer-1) + *(RAW8buffer+1))/2;
				} else {
					nValue = *(RAW8buffer);
				}
			*Bplane = nValue;
		
		Rplane+=3;
		Gplane+=3;
		Bplane+=3;
		RAW8buffer++;
		}
	}
}
*/
void ConvertRaw8ToRGB (unsigned char *RGBbuffer, unsigned char *RAW8buffer, int nXsize, int nYsize)
{
	unsigned char *Rplane = RGBbuffer+2;
	unsigned char *Gplane = RGBbuffer+1;
	unsigned char *Bplane = RGBbuffer;
	
	int x,y;
	
	for (y = 0; y < nYsize; y++) {
		for (x = 0; x < nXsize; x++) {
			if (y == 0)
				if (x == 0) {
					*Rplane = *(RAW8buffer+nXsize+1);
					*Gplane = (*(RAW8buffer+1) + *(RAW8buffer+nXsize))/2;
					*Bplane = *(RAW8buffer);
				} else if (x == nXsize-1) {
					*Rplane = *(RAW8buffer+nXsize);
					*Gplane = *(RAW8buffer);
					*Bplane = *(RAW8buffer-1);
				} else if (x & 0x01) {
					*Rplane = *(RAW8buffer+nXsize);
					*Gplane = *(RAW8buffer);
					*Bplane = (*(RAW8buffer-1) + *(RAW8buffer+1))/2;
				} else {
					*Rplane = (*(RAW8buffer+nXsize-1) + *(RAW8buffer+nXsize+1))/2;
					*Gplane = (*(RAW8buffer-1) + *(RAW8buffer+1) + *(RAW8buffer+nXsize))/3;
					*Bplane = *(RAW8buffer);
				}
			else if (y == nYsize-1)
				if (x == 0) {
					*Rplane = *(RAW8buffer+1);
					*Gplane = *(RAW8buffer);
					*Bplane = *(RAW8buffer-nXsize);
				} else if (x == nXsize-1) {
					*Rplane = *(RAW8buffer);
					*Gplane = (*(RAW8buffer-nXsize) + *(RAW8buffer-1))/2;
					*Bplane = *(RAW8buffer-nXsize-1);
				} else if (x & 0x01) {
					*Rplane = *(RAW8buffer);
					*Gplane = (*(RAW8buffer-1) + *(RAW8buffer+1) + *(RAW8buffer-nXsize))/3;
					*Bplane = (*(RAW8buffer-nXsize-1) + *(RAW8buffer-nXsize+1))/2;
				} else {
					*Rplane = (*(RAW8buffer-1) + *(RAW8buffer+1))/2;
					*Gplane = *(RAW8buffer);
					*Bplane = *(RAW8buffer-nXsize);
				}
			else if (y & 0x01) // y is odd
				if (x == 0) {
					*Rplane = *(RAW8buffer+1);
					*Gplane = *(RAW8buffer);
					*Bplane = (*(RAW8buffer-nXsize) + *(RAW8buffer+nXsize))/2;
				} else if (x == nXsize-1) {
					*Rplane = *(RAW8buffer);
					*Gplane = (*(RAW8buffer-1) + *(RAW8buffer-nXsize) + *(RAW8buffer+nXsize))/3;
					*Bplane = (*(RAW8buffer-nXsize-1) + *(RAW8buffer+nXsize-1))/2;
				} else if (x & 0x01) {
					*Rplane = *(RAW8buffer);
					*Gplane = (*(RAW8buffer-1) + *(RAW8buffer-nXsize)
							+ *(RAW8buffer+1) + *(RAW8buffer+nXsize))/4;
					*Bplane = (*(RAW8buffer-nXsize-1) + *(RAW8buffer-nXsize+1)
							+ *(RAW8buffer+nXsize-1) + *(RAW8buffer+nXsize+1))/4;
				} else {
					*Rplane = (*(RAW8buffer-1) + *(RAW8buffer+1))/2;
					*Gplane = *(RAW8buffer);
					*Bplane = (*(RAW8buffer-nXsize) + *(RAW8buffer+nXsize))/2;
				}
			else // y is even
				if (x == 0) {
					*Rplane = (*(RAW8buffer-nXsize+1) + *(RAW8buffer+nXsize+1))/2;
					*Gplane = (*(RAW8buffer+1) + *(RAW8buffer-nXsize) + *(RAW8buffer+nXsize))/3;
					*Bplane = *(RAW8buffer);
				} else if (x == nXsize-1) {
					*Rplane = (*(RAW8buffer-nXsize) + *(RAW8buffer+nXsize))/2;
					*Gplane = *(RAW8buffer);
					*Bplane = *(RAW8buffer-1);
				} else if (x & 0x01) {
					*Rplane = (*(RAW8buffer-nXsize) + *(RAW8buffer+nXsize))/2;
					*Gplane = *(RAW8buffer);
					*Bplane = (*(RAW8buffer-1) + *(RAW8buffer+1))/2;
				} else {
					*Rplane = (*(RAW8buffer-nXsize-1) + *(RAW8buffer-nXsize+1)
							+ *(RAW8buffer+nXsize-1) + *(RAW8buffer+nXsize+1))/4;
					*Gplane = (*(RAW8buffer-1) + *(RAW8buffer-nXsize)
							+ *(RAW8buffer+1) + *(RAW8buffer+nXsize))/4;
					*Bplane = *(RAW8buffer);
				}
		
			Rplane+=3;
			Gplane+=3;
			Bplane+=3;
			RAW8buffer++;
		}
	}
}

void ConvertRGB565ToRGB (unsigned char *RGBbuffer, unsigned char *RGB565buffer, int nXsize, int nYsize)
{
	unsigned char *Rplane = RGBbuffer+2;
	unsigned char *Gplane = RGBbuffer+1;
	unsigned char *Bplane = RGBbuffer;
	
	int x,y;
	
	for (y = 0; y < nYsize; y++) {
		for (x = 0; x < nXsize; x++) {

			unsigned short nRGBvalue = (((*RGB565buffer)&0xFF)<<8)|(*(RGB565buffer+1)&0xFF);
			*Bplane = (nRGBvalue & 0x1f) << 3;
			*Gplane = ((nRGBvalue >> 5) & 0x3f) << 2;
			*Rplane = ((nRGBvalue >> 11) & 0x1f) << 3;
		
			Rplane+=3;
			Gplane+=3;
			Bplane+=3;
			RGB565buffer+=2;
		}
	}
}

int ConvertRGBToWindowsBmp (int xlength, int ylength, int img_width, int img_height, unsigned char *pa_nBuffer, unsigned char *pa_nOutBuffer) {
	// creating bmp header
	char headerbyte[54] = {0};
	headerbyte[0]	= 'B';
	headerbyte[1]	= 'M';
	headerbyte[10]	= 54;
	headerbyte[11]	= 0;
	headerbyte[14]	= 40;
	headerbyte[26]	= 1;
	headerbyte[28]	= 24;
	headerbyte[38]	= 1;
	headerbyte[39]	= 126;
	headerbyte[40]	= 8;
	headerbyte[41]	= 48;
	headerbyte[42]	= 66;
	headerbyte[44]	= 100;
	headerbyte[47]	= 1;

	headerbyte[18]  = (char)(img_width & 0x00ff);
	headerbyte[19]  = (char)((img_width >> 8) & 0x00ff); 
	headerbyte[22]  = (char)(img_height & 0x00ff);
	headerbyte[23]  = (char)((img_height >> 8) & 0x00ff);

	int nRest = img_width % 4;
	unsigned long filesize = 54 + img_width * img_height * 3 + img_height * nRest;

	headerbyte[2] = (char)(filesize & 0xff);
	headerbyte[3] = (char)((filesize >> 8) & 0xff);
	headerbyte[4] = (char)((filesize >> 16) & 0xff);
	headerbyte[5] = (char)((filesize >> 24) & 0xff);

	// writing header to out buffer
	unsigned char *pcIndex = (unsigned char *)pa_nOutBuffer;
	int i = 0;
	while (i < 54) {
		*pcIndex++ = headerbyte[i++];
	}

	// writing image data to outbuffer
	int x = 0;
	int nDiff = (1+ xlength/img_width) * xlength*3;
	unsigned char *memIndexRGB = (pa_nBuffer + (ylength - 1) * xlength * 3);
	while (memIndexRGB >= pa_nBuffer) {
		x = 0;
		while(x<xlength) {
			*(pcIndex++) = *(memIndexRGB++);
			*(pcIndex++) = *(memIndexRGB++);
			*(pcIndex++) = *(memIndexRGB++);
			memIndexRGB += (xlength/img_width -1)*3;
			x+=(xlength/img_width);
		}
		i = 0;
		while (i++ < nRest) {
			*(pcIndex++) = 0;
		}
		memIndexRGB -= nDiff;
	}		

	return filesize;
}

void TFT_Init () {
	int fd = -1;//frame buffer(display ) id	
	struct fb_var_screeninfo vi, initial_vi;//two struct  is used to get display info