cameratest.c

三星2443芯片

#include "system.h"
#include "Display.h"
#include "Camera.h"
#include "CameraData.h"

typedef struct {
	int	ITU601_656;
	int Order422;
	int Hsize;
	int Vsize;
	int PCLKpolarity;
	int VSYNCpolarity;
	int HREFpolarity;
	char PageRegister;
	void *CamData;
	int	Size;
} CAMERAMODULE;

CAMERAMODULE CameraModule[]=
{
	{ CAMERA_ITU601, ORDER_YCBYCR,  640,  480, InvPolPCLK_INVERSE, InvPolVSYNC_NORMAL, InvPolHREF_NORMAL, 0xec, S5K3AA_YCbCr8bit_VGA, sizeof(S5K3AA_YCbCr8bit_VGA)/2},
	{ CAMERA_ITU656, ORDER_CBYCRY, 1280, 1024, InvPolPCLK_INVERSE, InvPolVSYNC_NORMAL, InvPolHREF_NORMAL, 0xec, S5K3AA_YCbCr8bit_SXGA_656, sizeof(S5K3AA_YCbCr8bit_SXGA_656)/2},
	{ CAMERA_ITU601, ORDER_YCRYCB,  176,  144, InvPolPCLK_NORMAL, InvPolVSYNC_INVERSE, InvPolHREF_NORMAL, 0xfc, S5K3BAFB_YCbCr8bit_QCIF, sizeof(S5K3BAFB_YCbCr8bit_QCIF)/2},
	{ CAMERA_ITU601, ORDER_YCRYCB,  320,  240, InvPolPCLK_NORMAL, InvPolVSYNC_INVERSE, InvPolHREF_NORMAL, 0xfc, S5K3BAFB_YCbCr8bit_QVGA, sizeof(S5K3BAFB_YCbCr8bit_QVGA)/2},
	{ CAMERA_ITU601, ORDER_YCRYCB,  640,  480, InvPolPCLK_NORMAL, InvPolVSYNC_INVERSE, InvPolHREF_NORMAL, 0xfc, S5K3BAFB_YCbCr8bit_VGA, sizeof(S5K3BAFB_YCbCr8bit_VGA)/2},
	{ CAMERA_ITU601, ORDER_YCRYCB, 1280, 1024, InvPolPCLK_NORMAL, InvPolVSYNC_INVERSE, InvPolHREF_NORMAL, 0xfc, S5K3BAFB_YCbCr8bit_SXGA, sizeof(S5K3BAFB_YCbCr8bit_SXGA)/2},
	{ CAMERA_ITU601, ORDER_YCRYCB, 1600, 1200, InvPolPCLK_NORMAL, InvPolVSYNC_INVERSE, InvPolHREF_NORMAL, 0xfc, S5K3BAFB_YCbCr8bit_UXGA, sizeof(S5K3BAFB_YCbCr8bit_UXGA)/2}
};


#define	CameraPreviewFrameBuffer	(_NONCACHE_STARTADDRESS+0x01000000)
#define	CameraCodecFrameBuffer		(_NONCACHE_STARTADDRESS+0x01800000)

#define CAPTURE_STOPPED				(0)
#define CAPTURING					(1)
#define CAPTURE_STOP_ISSUED			(2)
#define CAPTURE_LASTIRQ_ISSUED		(3)
#define CAPTURE_LAST_IRQ			(4)


#define CAMIICID		(0x5a)

static int CAMTYPE;

static volatile unsigned int camCodecCaptureCount, camCodecStatus, camCodecDataValid;
static volatile unsigned int camPviewCaptureCount, camPviewStatus, camPviewDataValid;
static volatile unsigned int PreviewComplete;

static int TESTPATTERN, FLIPMODE;

void InitCameraModule( void)
{
	printf("Select camera type\n");
	printf("0: S5K3AA (VGA)      1: S3K3AA (SXGA-ITU656)    2: S5K3BAFB (QCIF)     3: S5K3BAFB (QVGA)\n");
	printf("4: S5K3BAFB (VGA)    5: S5K3BAFB (SXGA)         6: S5K3BAFB (UXGA)\n");
	printf("Choose one [D=0]:");

	CAMTYPE = GetIntNum();

	if ((CAMTYPE<0)||(CAMTYPE>=sizeof(CameraModule)/40))
		CAMTYPE = 0;

	OpenCameraIIC(400000);
	SetupCameraModule( CAMIICID, CameraModule[CAMTYPE].CamData, CameraModule[CAMTYPE].Size );
	CloseCameraIIC();

	ResetCameraInterface();
	SetCameraSourceFormat(CameraModule[CAMTYPE].ITU601_656,UVOFFSET_0,CameraModule[CAMTYPE].Order422);
	SetCameraSourceSize(CameraModule[CAMTYPE].Hsize,CameraModule[CAMTYPE].Vsize);
	SetCameraInterfacePolarity(CameraModule[CAMTYPE].PCLKpolarity,CameraModule[CAMTYPE].VSYNCpolarity,CameraModule[CAMTYPE].HREFpolarity);
	SetCameraWindowOffset(WINDOWOFFSET_DISABLE,0,0,0,0);

	printf("\n\nCamera Module Initialize complete.\n");
}

void ReadCameraModuleStatus( void)
{
	unsigned int i;
	char Data;
	char *A;

	OpenCameraIIC(400000);

	A =	CameraModule[CAMTYPE].CamData;

	for(i=0; i<CameraModule[CAMTYPE].Size;i++) {
		if(A[i*2+0] == CameraModule[CAMTYPE].PageRegister) {
			WriteCameraModule( CAMIICID, CameraModule[CAMTYPE].PageRegister, A[i*2+1]);
			printf("Page: 0x%02x\n",  A[i*2+1]);
		} else {
			ReadCameraModule( CAMIICID, A[i*2+0], &Data);
			printf("Addr: 0x%02x, W: 0x%02x, R: 0x%02x\n", A[i*2+0], A[i*2+1], Data);
		}
	}

	CloseCameraIIC();
}




void __irq CameraISR( void)
{
	if (rSUBSRCPND & BIT_SUB_CAM_P) {
		rSUBSRCPND = BIT_SUB_CAM_P;
		printf("p");
		CameraIF_PreviewISR();
	}
	
	if (rSUBSRCPND & BIT_SUB_CAM_C) {
		rSUBSRCPND = BIT_SUB_CAM_C;
		printf("c");
		CameraIF_CodecISR();
	}
	
	ClearPending(BIT_CAM);
}

void __irq MSDMAISR( void)
{
	if (rSUBSRCPND & BIT_SUB_CAM_P) {
		rSUBSRCPND = BIT_SUB_CAM_P;
		printf("m");
		PreviewComplete = 1;
	}

	if (rSUBSRCPND & BIT_SUB_CAM_C) {
		rSUBSRCPND = BIT_SUB_CAM_C;
		printf("c");
		CameraIF_CodecISR();
	}
	
	ClearPending(BIT_CAM);
}



//************************************************************************
//*		Codec test
//************************************************************************

void CodecCaptureStart( void)
{ 
	camCodecCaptureCount	=	0;
	camCodecStatus			=	CAPTURING;

	EnableCodecDMA();
	EnableCodecScaler();
	EnableImageCaptureCodec();
	EnableImageCapture();
}

void CodecCaptureStop(void)
{
	camCodecStatus	=	CAPTURE_STOP_ISSUED;
}

void CameraIF_CodecISR(void)
{
	switch(camCodecStatus) {

	case CAPTURE_STOPPED	:					//	It will never happen.
			break;

	case CAPTURING	:
			break;

	case CAPTURE_STOP_ISSUED	:
			EnableCodecLastIRQ();
			camCodecStatus	=	CAPTURE_LASTIRQ_ISSUED;
			break;

	case CAPTURE_LASTIRQ_ISSUED	:
			DisableImageCapture();
			DisableImageCaptureCodec();
			DisableCodecScaler();
			DisableCodecDMA();
			camCodecStatus	=	CAPTURE_LAST_IRQ;
			break;			

	case CAPTURE_LAST_IRQ	:
			camCodecStatus	=	CAPTURE_STOPPED;
			break;
	}

	if (camCodecCaptureCount>0)
		camCodecDataValid	=	1;

	camCodecCaptureCount++;	
}


void CameraCodec( void)
{
	unsigned int OutFormat = 0;
	int i, fb;

	switch(lcd_bpp)
	{
	case WINCONx_16BPP_565 : 
		OutFormat = OutFormat_RGB16B;
		break;
	case WINCONx_24BPP_888 : 
		OutFormat = OutFormat_RGB24B;
		break;
	}

	printf("Camera Codec path test.\n");

	camCodecStatus=CAPTURE_STOPPED;
	camCodecCaptureCount=0;
	camCodecDataValid=0;

	pISR_CAM	=	(unsigned int)CameraISR;
	rSUBSRCPND = BIT_SUB_CAM_P|BIT_SUB_CAM_C;
	ClearPending(BIT_CAM);
	rINTSUBMSK &= ~BIT_SUB_CAM_C;
	rINTMSK &= ~BIT_CAM;

	SetCodecFormat( InFormat_YCBCR422, OutFormat, INTERLEAVE_ON, ORDER_YCBYCR);
	SetCodecScaler( CameraModule[CAMTYPE].Hsize, CameraModule[CAMTYPE].Vsize, lcd_horizon_value, lcd_line_value);
	SetCodecDMA( lcd_horizon_value, lcd_line_value, OutFormat, INTERLEAVE_ON);
	SetCodecFrameBuffer( CameraCodecFrameBuffer, lcd_horizon_value, lcd_line_value, OutFormat, INTERLEAVE_ON);

	SetCodecFlipMode(FLIPMODE);
	SetCameraTestPattern(TESTPATTERN);

	CodecCaptureStart();

	while (1) {
		if (camCodecDataValid) {
			camCodecDataValid = 0;
			i = (GetCodecFrameCount()-2)&0x3;
			fb = GetCodecFrameBuffer(i);

			*VIDWxADD0_Reg_Addr[0][0] = fb;
		}
		if (Uart_GetKey()== '\r') break;			
	}

	CodecCaptureStop();

	while(!(camCodecStatus==CAPTURE_STOPPED ));

	printf("\ncamCodecCaptureCount=%d\n",camCodecCaptureCount);
	printf("codec Status register:0x%x\n", rCICOSTATUS);

	rINTMSK |= BIT_CAM;
	rINTSUBMSK |= BIT_SUB_CAM_C;
}

void CameraCodec_ScanLine_Offset( void)
{
	unsigned int OutFormat = 0;
	unsigned int i,fb;

	unsigned int *Codecframebuffer, *Previewframebuffer;
	unsigned int TargetHsize, TargetVsize;//, StartPixelNumber;

	printf("CPU I/F Display Controller Test!\n");

	TargetHsize = 160;
	TargetVsize =120;
	//StartPixelNumber = 160;

	Codecframebuffer = (U32 *)CameraCodecFrameBuffer;
	Previewframebuffer = (U32 *)CameraPreviewFrameBuffer;


	switch(lcd_bpp)
	{
	case WINCONx_16BPP_565 : 
		OutFormat = OutFormat_RGB16B;
		break;
	case WINCONx_24BPP_888 : 
		OutFormat = OutFormat_RGB24B;
		break;
	}

	printf("MSDMA test. (Get YCBCR data from camera with codec path. And put the image into MSDMA.)\n");

	camCodecStatus=CAPTURE_STOPPED;
	camCodecCaptureCount=0;
	camCodecDataValid=0;

	pISR_CAM	=	(unsigned int)MSDMAISR;
	rSUBSRCPND = BIT_SUB_CAM_P|BIT_SUB_CAM_C;
	ClearPending(BIT_CAM);
	rINTSUBMSK &= ~(BIT_SUB_CAM_P|BIT_SUB_CAM_C);
	rINTMSK &= ~BIT_CAM;

	for(i=0; i<240*320*2*4; i++) {
		*Codecframebuffer ++ = 0x0;
	}
	for(i=0; i<240*320*2*4; i++) {
		*Previewframebuffer ++ = 0x0;
	}	

	SetCodecFormat( InFormat_YCBCR422, OutFormat_YCBCR422, INTERLEAVE_ON, ORDER_CRYCBY);
	SetCodecScaler( CameraModule[CAMTYPE].Hsize, CameraModule[CAMTYPE].Vsize, TargetHsize, TargetVsize);
	SetCodecDMA( 160, 120, OutFormat_YCBCR422, INTERLEAVE_ON);	
	SetCodec_ScanLine_Bubffer(2);

	//	Use MSDMA Offset
	SetPreviewPath( 320, 240, lcd_horizon_value, lcd_line_value, OutFormat);
	SetPreviewFrameBuffer( CameraPreviewFrameBuffer, lcd_horizon_value, lcd_line_value, OutFormat);
	SetPreviewSource( PREVIEW_MSDMA);

	SetMSDMAFormat( MSDMA_InFormat_YCBCR422, INTERLEAVE_ON, ORDER_CRYCBY);
/*
	rCIIMGCPT |=  (1<<24) | (0<<18) | (0x0<<19);
	rCICOCPTSEQ = 0xa;
*/
	CodecCaptureStart();

	EnablePreviewScaler();
	EnableImageCapturePreview();

	printf("\nrCIMSCTRL = %x\n",rCIMSCTRL);

	while (1) {
		if (camCodecDataValid) {
			camCodecDataValid = 0;

			i = GetCodecFrameCount();
				
			Return_ScanLine_BubfferAddr();
			
			fb = GetCodecFrameBuffer((i-2)&0x3);

			SetMSDMAFrameBuffer( fb, lcd_horizon_value, lcd_line_value, 0, MSDMA_InFormat_YCBCR422);

			PreviewComplete=0;

			StartMSDMA();
			WaitMSDMA();

			SetCodec_ScanLine_Bubffer(2);

			while(PreviewComplete==0);

			i = GetPreviewFrameCount();
			fb = GetPreviewFrameBuffer((i-1)&0x3);

			*VIDWxADD0_Reg_Addr[0][0] = fb;

		}
		if (Uart_GetKey()== '\r') break;			
	}

	DisableImageCapturePreview();
	DisablePreviewScaler();

	CodecCaptureStop();

	while(!(camCodecStatus==CAPTURE_STOPPED ));

	printf("\ncamCodecCaptureCount=%d\n",camCodecCaptureCount);
	printf("codec Status register:0x%x\n", rCICOSTATUS);

	rINTMSK |= BIT_CAM;
	rINTSUBMSK |= BIT_SUB_CAM_P|BIT_SUB_CAM_C;
}

void Return_ScanLine_BubfferAddr()