cfa2bmp.c

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

/*******************************************************************************
 * 
 * Filename:    $Id: cfa2bmp.c,v 1.1 2002/04/22 10:03:47 jill Exp $
 * 
 * Description: Converts a 96x72x4 bit Bayer Pattern CFA to a 96x72 bitmap
 * 
 * History:
 * --------
 * $Log: cfa2bmp.c,v $
 * Revision 1.1  2002/04/22 10:03:47  jill
 * Initial import
 *
 * Revision 1.2  1998/05/07 10:59:15  graham
 * Made common header for functions & increased buffer size to BUFSIZ*15
 *
 * Revision 1.1  1998/04/28 12:17:22  graham
 * Initial version
 *
 *
 ******************************************************************************/

/* system includes */

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>

#define WIDTH    1600
#define HEIGHT   1200

void ConvertRawToRaw10 (unsigned short *RAW10buffer, unsigned char *RAWbuffer, int nXsize, int nYsize)
{
	int nPixelCount = nXsize * nYsize;
	unsigned short nValue;
	unsigned short nValueHigh;
	unsigned short nValueLow;
	
	
	while (nPixelCount) {
		nValueLow = *(RAWbuffer+1) & 0x0002;
		nValueHigh = *(RAWbuffer) & 0x00ff;
		*RAW10buffer = ((nValueHigh << 2) & 0x03fc) | (nValueLow);
		RAW10buffer++;
		RAWbuffer+=2;
		nPixelCount--;
	}
}

void ConvertRaw10ToRGB (unsigned char *RGBbuffer, unsigned short *RAW10buffer, int nXsize, int nYsize)
{
	unsigned char *Rplane = RGBbuffer+2;
	unsigned char *Gplane = RGBbuffer+1;
	unsigned char *Bplane = RGBbuffer;
	
	unsigned short 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 = *(RAW10buffer+nXsize+1);
				} else if (x & 0x01) {
					nValue = *(RAW10buffer+nXsize);
				} else {
					nValue = (*(RAW10buffer+nXsize-1) + *(RAW10buffer+nXsize+1))/2;
				}
			else if (y & 0x01)
				if (x == 0) {
					nValue = *(RAW10buffer+1);
				} else if (x & 0x01) {
					nValue = *(RAW10buffer);
				} else {
					nValue = (*(RAW10buffer-1) + *(RAW10buffer+1))/2;
				}
			else
				if (x == 0) {
					nValue = (*(RAW10buffer-nXsize+1) + *(RAW10buffer+nXsize+1))/2;
				} else if (x & 0x01) {
					nValue = (*(RAW10buffer-nXsize) + *(RAW10buffer+nXsize))/2;
				} else {
					nValue = (*(RAW10buffer-nXsize-1) + *(RAW10buffer-nXsize+1)
							+ *(RAW10buffer+nXsize-1) + *(RAW10buffer+nXsize+1))/4;
				}
			nValue = (nValue>>2) & 0xff;
			*Rplane = (unsigned char)nValue;

			// Calculate Gplane
			if (y == 0)
				if (x == 0) {
					nValue = (*(RAW10buffer+1) + *(RAW10buffer+nXsize))/2;
				} else if (x & 0x01) {
					nValue = *(RAW10buffer);
				} else {
					nValue = (*(RAW10buffer-1) + *(RAW10buffer+1) + *(RAW10buffer+nXsize))/3;
				}
			else if (y == nYsize-1)
				if (x == nXsize-1) {
					nValue = (*(RAW10buffer-nXsize) + *(RAW10buffer-1))/2;
				} else if (x & 0x01) {
					nValue = (*(RAW10buffer-1) + *(RAW10buffer+1) + *(RAW10buffer-nXsize))/3;
				} else {
					nValue = *(RAW10buffer);
				}
			else if (y & 0x01)
				if (x == nXsize-1) {
					nValue = (*(RAW10buffer-1) + *(RAW10buffer-nXsize) + *(RAW10buffer+nXsize))/3;
				} else if (x & 0x01) {
					nValue = (*(RAW10buffer-1) + *(RAW10buffer-nXsize)
							+ *(RAW10buffer+1) + *(RAW10buffer+nXsize))/4;
				} else {
					nValue = *(RAW10buffer);
				}
			else
				if (x == 0) {
					nValue = (*(RAW10buffer+1) + *(RAW10buffer-nXsize) + *(RAW10buffer+nXsize))/3;
				} else if (x & 0x01) {
					nValue = *(RAW10buffer);
				} else {
					nValue = (*(RAW10buffer-1) + *(RAW10buffer-nXsize)
							+ *(RAW10buffer+1) + *(RAW10buffer+nXsize))/4;
				}
			nValue = (nValue>>2) & 0xff;
			*Gplane = (unsigned char)nValue;
			
			// Calculate Bplane
			if (y == nYsize-1)
				if (x == nXsize-1) {
					nValue = *(RAW10buffer-nXsize-1);
				} else if (x & 0x01) {
					nValue = (*(RAW10buffer-nXsize-1) + *(RAW10buffer-nXsize+1))/2;
				} else {
					nValue = *(RAW10buffer-nXsize);
				}
			else if (y & 0x01)
				if (x == nXsize-1) {
					nValue = (*(RAW10buffer-nXsize-1) + *(RAW10buffer+nXsize-1))/2;
				} else if (x & 0x01) {
					nValue = (*(RAW10buffer-nXsize-1) + *(RAW10buffer-nXsize+1)
							+ *(RAW10buffer+nXsize-1) + *(RAW10buffer+nXsize+1))/4;
				} else {
					nValue = (*(RAW10buffer-nXsize) + *(RAW10buffer+nXsize))/2;
				}
			else
				if (x == nXsize-1) {
					nValue = *(RAW10buffer-1);
				} else if (x & 0x01) {
					nValue = (*(RAW10buffer-1) + *(RAW10buffer+1))/2;
				} else {
					nValue = *(RAW10buffer);
				}
			nValue = (nValue>>2) & 0xff;
			*Bplane = (unsigned char)nValue;
		
		Rplane+=3;
		Gplane+=3;
		Bplane+=3;
		RAW10buffer++;
		}
	}
}

// creates a windows bmp compatible format from an rgb 24 bit image
int ConvertRGBToWindowsBmp (int xlength, int ylength, 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)(xlength & 0x00ff);
	headerbyte[19]  = (char)((xlength >> 8) & 0x00ff); 
	headerbyte[22]  = (char)(ylength & 0x00ff);
	headerbyte[23]  = (char)((ylength >> 8) & 0x00ff);

	int nRest = xlength % 4;
	unsigned long filesize = 54 + xlength * ylength * 3 + ylength * 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 = 2 * 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++);
			x++;
		}
		i = 0;
		while (i++ < nRest) {
			*(pcIndex++) = 0;
		}
		memIndexRGB -= nDiff;
	}		

	return filesize;
}


/******************************************************************************/
/*                                                                            */
/* Unit:        main()                                                        */
/*                                                                            */
/* Description: ifdef'd main() to test the cfa2bmp function above             */
/*                                                                            */
/* Notes:                                                                     */
/*                                                                            */
/* Parameters:  argv[1]  -  filename of raw bayer pattern cfa data            */
/*              argv[2]  -  filename in which to place the bitmap             */
/*                                                                            */
/* Globals:     None                                                          */
/*                                                                            */
/* Returns:    -1  -  Bad argument                                            */
/*              0  -  All converted                                           */
/*                                                                            */
/******************************************************************************/
int main( int argc, char *argv[] )
{
    int fd;

	int nXsize = WIDTH;
	int nYsize = HEIGHT;

	unsigned char *buffer;
	unsigned char *bitmap;

	buffer = (unsigned char *)malloc(2*nXsize*nYsize);

    /* check the args */

    if ( (argv[1] == NULL) || (argv[2] == NULL) )
    {
        (void) printf( "Usage: %s filename.cfa filename.bmp\n", argv[0] );
        exit( -1 );
    }


    /* read in the thumbnail data */

    fd = open( argv[1], O_RDONLY );

    if ( fd == -1 )
    {
        (void) printf( "%s: failed to open \"%s\"", argv[0], argv[1] );
        exit( -1 );
    }

	(void) read(fd, buffer, 2*nXsize*nYsize);
    (void) close( fd );
	
	unsigned char *RAWbuffer = buffer;
	unsigned short *RAW10buffer = (unsigned short *)malloc(nXsize*nYsize*sizeof(short));

	ConvertRawToRaw10(RAW10buffer, RAWbuffer, nXsize, nYsize);
	free(buffer);
	unsigned char *RGBbuffer = (unsigned char *)malloc(3*nXsize*nYsize);
	ConvertRaw10ToRGB(RGBbuffer, RAW10buffer, nXsize, nYsize);
	free(RAW10buffer);
	// creates a windows bmp compatible format from an rgb 24 bit image
	bitmap = (unsigned char *)malloc(3*nXsize*nYsize+54);
	int filesize = ConvertRGBToWindowsBmp(WIDTH, HEIGHT, RGBbuffer, bitmap);
	free(RGBbuffer);

    fd = open( argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0666 );

    if ( fd == -1 )
    {
        (void) printf( "%s: failed to open \"%s\"", argv[0], argv[2] );
        exit( -1 );
    }
    (void) write( fd, bitmap, filesize );
    (void) close( fd );
	
	free(bitmap);

    exit( 0 );
}