divisor = 4; //CCIR-420

	//constant for calculating preview dma address
	if ( CAM_PVIEW_OUTPUT )
		multiplier = 4;
	else
		multiplier = 2;

	if ( WinHorOffset == 0 && WinVerOffset == 0 )
		WinOfsEn = 0;
	else
		WinOfsEn = 1;

	SrcWidth = CAM_SRC_HSIZE - WinHorOffset * 2;
	SrcHeight = CAM_SRC_VSIZE - WinVerOffset * 2;

	if ( SrcWidth >= CoDstWidth )
		ScaleUp_H_Co = 0; //down
	else
		ScaleUp_H_Co = 1;		//up

	if ( SrcHeight >= CoDstHeight )
		ScaleUp_V_Co = 0;
	else
		ScaleUp_V_Co = 1;		

	if ( SrcWidth >= PrDstWidth )
		ScaleUp_H_Pr = 0; //down
	else
		ScaleUp_H_Pr = 1;		//up

	if ( SrcHeight >= PrDstHeight )
		ScaleUp_V_Pr = 0;   // edited 040225
	else
		ScaleUp_V_Pr = 1;		

	////////////////// common control setting
	rCIGCTRL |= ( 1 << 26 ) | ( 0 << 27 ); // inverse PCLK, test pattern--- hzh
	//rCIGCTRL |= (0<<26)|(0<<27); // don't inverse PCLK, test pattern
	rCIWDOFST = ( 1 << 30 ) | ( 0xf << 12 ); // clear overflow 
	rCIWDOFST = 0 ;	
	rCIWDOFST = ( WinOfsEn << 31 ) | ( WinHorOffset << 16 ) | ( WinVerOffset );
	rCISRCFMT = ( CAM_ITU656 << 31 ) |
		( 1 << 30 ) |
		( 0 << 29 ) |
		( CAM_SRC_HSIZE << 16 ) |
		( CAM_ORDER_YCBYCR << 14 ) |
		( CAM_SRC_VSIZE );
	//--- hzh
	//rCISRCFMT=(CAM_ITU601<<31)|(1<<30)|(0<<29)|(CAM_SRC_HSIZE<<16)|(CAM_ORDER_YCBYCR<<14)|(CAM_SRC_VSIZE);
	//---

	////////////////// codec port setting
	if ( CAM_CODEC_4PP )
	{
		rCICOYSA1 = CoFrameBuffer;
		rCICOYSA2 = rCICOYSA1 + CoDstWidth * CoDstHeight + 2 * CoDstWidth * CoDstHeight / divisor;
		rCICOYSA3 = rCICOYSA2 + CoDstWidth * CoDstHeight + 2 * CoDstWidth * CoDstHeight / divisor;
		rCICOYSA4 = rCICOYSA3 + CoDstWidth * CoDstHeight + 2 * CoDstWidth * CoDstHeight / divisor;

		rCICOCBSA1 = rCICOYSA1 + CoDstWidth * CoDstHeight;
		rCICOCBSA2 = rCICOYSA2 + CoDstWidth * CoDstHeight;
		rCICOCBSA3 = rCICOYSA3 + CoDstWidth * CoDstHeight;
		rCICOCBSA4 = rCICOYSA4 + CoDstWidth * CoDstHeight;

		rCICOCRSA1 = rCICOCBSA1 + CoDstWidth * CoDstHeight / divisor;
		rCICOCRSA2 = rCICOCBSA2 + CoDstWidth * CoDstHeight / divisor;
		rCICOCRSA3 = rCICOCBSA3 + CoDstWidth * CoDstHeight / divisor;
		rCICOCRSA4 = rCICOCBSA4 + CoDstWidth * CoDstHeight / divisor;
	}
	else
	{
		rCICOYSA1 = CoFrameBuffer;
		rCICOYSA2 = rCICOYSA1;
		rCICOYSA3 = rCICOYSA1;
		rCICOYSA4 = rCICOYSA1;

		rCICOCBSA1 = rCICOYSA1 + CoDstWidth * CoDstHeight;
		rCICOCBSA2 = rCICOCBSA1;
		rCICOCBSA3 = rCICOCBSA1;
		rCICOCBSA4 = rCICOCBSA1;

		rCICOCRSA1 = rCICOCBSA1 + CoDstWidth * CoDstHeight / divisor;
		rCICOCRSA2 = rCICOCRSA1;
		rCICOCRSA3 = rCICOCRSA1;
		rCICOCRSA4 = rCICOCRSA1;
	}
	
	rCICOTRGFMT = ( CAM_CODEC_IN_422 << 31 ) |
		( CAM_CODEC_OUTPUT << 30 ) |
		( CoDstWidth << 16 ) |
		( CAM_FLIP_NORMAL << 14 ) |
		( CoDstHeight );

	CalculateBurstSize( CoDstWidth , &MainBurstSizeY , &RemainedBurstSizeY );
	CalculateBurstSize( CoDstWidth / 2 , &MainBurstSizeC , &RemainedBurstSizeC );
	rCICOCTRL = ( MainBurstSizeY << 19 ) |
		( RemainedBurstSizeY << 14 ) |
		( MainBurstSizeC << 9 ) |
		( RemainedBurstSizeC << 4 );

	CalculatePrescalerRatioShift( SrcWidth , CoDstWidth , &PreHorRatio , &H_Shift );
	CalculatePrescalerRatioShift( SrcHeight , CoDstHeight , &PreVerRatio , &V_Shift );
	MainHorRatio = ( SrcWidth << 8 ) / ( CoDstWidth << H_Shift );
	MainVerRatio = ( SrcHeight << 8 ) / ( CoDstHeight << V_Shift );

	rCICOSCPRERATIO = ( ( 10 - H_Shift - V_Shift ) << 28 ) | ( PreHorRatio << 16 ) | ( PreVerRatio );
	rCICOSCPREDST = ( ( SrcWidth / PreHorRatio ) << 16 ) | ( SrcHeight / PreVerRatio ); 
	rCICOSCCTRL = ( CAM_SCALER_BYPASS_OFF << 31 ) |
		( ScaleUp_H_Co << 30 ) |
		( ScaleUp_V_Co << 29 ) |
		( MainHorRatio << 16 ) |
		( MainVerRatio );

	rCICOTAREA = CoDstWidth * CoDstHeight;

	///////////////// preview port setting
	if ( CAM_PVIEW_4PP ) // codec view mode
	{
		rCIPRCLRSA1 = PrFrameBuffer;
		rCIPRCLRSA2 = rCIPRCLRSA1 + PrDstWidth * PrDstHeight * multiplier;
		rCIPRCLRSA3 = rCIPRCLRSA2 + PrDstWidth * PrDstHeight * multiplier;
		rCIPRCLRSA4 = rCIPRCLRSA3 + PrDstWidth * PrDstHeight * multiplier;
	}
	else // direct preview mode
	{
		rCIPRCLRSA1 = ( U32 ) LCD_BUFFER_CAM;
		rCIPRCLRSA2 = ( U32 ) LCD_BUFFER_CAM;
		rCIPRCLRSA3 = ( U32 ) LCD_BUFFER_CAM;
		rCIPRCLRSA4 = ( U32 ) LCD_BUFFER_CAM;
	}	

	rCIPRTRGFMT = ( PrDstWidth << 16 ) | ( CAM_FLIP_NORMAL << 14 ) | ( PrDstHeight );

	if ( CAM_PVIEW_OUTPUT == CAM_RGB24B )
		CalculateBurstSize( PrDstWidth * 2 , &MainBurstSizeRGB , &RemainedBurstSizeRGB );
	else // RGB16B
		CalculateBurstSize( PrDstWidth * 2 , &MainBurstSizeRGB , &RemainedBurstSizeRGB );
	rCIPRCTRL = ( MainBurstSizeRGB << 19 ) | ( RemainedBurstSizeRGB << 14 );

	CalculatePrescalerRatioShift( SrcWidth , PrDstWidth , &PreHorRatio , &H_Shift );
	CalculatePrescalerRatioShift( SrcHeight , PrDstHeight , &PreVerRatio , &V_Shift );
	MainHorRatio = ( SrcWidth << 8 ) / ( PrDstWidth << H_Shift );
	MainVerRatio = ( SrcHeight << 8 ) / ( PrDstHeight << V_Shift );
	rCIPRSCPRERATIO = ( ( 10 - H_Shift - V_Shift ) << 28 ) | ( PreHorRatio << 16 ) | ( PreVerRatio );		 
	rCIPRSCPREDST = ( ( SrcWidth / PreHorRatio ) << 16 ) | ( SrcHeight / PreVerRatio );
	rCIPRSCCTRL = ( 1 << 31 ) |
		( CAM_PVIEW_OUTPUT << 30 ) |
		( ScaleUp_H_Pr << 29 ) |
		( ScaleUp_V_Pr << 28 ) |
		( MainHorRatio << 16 ) |
		( MainVerRatio );

	rCIPRTAREA = PrDstWidth * PrDstHeight;
}



/********************************************************
 CalculateBurstSize - Calculate the busrt lengths
 
 Description:	
 - dstHSize: the number of the byte of H Size.
 
*/
void CalculateBurstSize( U32 hSize , U32* mainBurstSize , U32* remainedBurstSize )
{
	U32 tmp;	
	tmp = ( hSize / 4 ) % 16;
	switch ( tmp )
	{
		case 0:
			*mainBurstSize = 16;
			*remainedBurstSize = 16;
			break;
		case 4:
			*mainBurstSize = 16;
			*remainedBurstSize = 4;
			break;
		case 8:
			*mainBurstSize = 16;
			*remainedBurstSize = 8;
			break;
		default:
			tmp = ( hSize / 4 ) % 8;
			switch ( tmp )
			{
				case 0:
					*mainBurstSize = 8;
					*remainedBurstSize = 8;
					break;
				case 4:
					*mainBurstSize = 8;
					*remainedBurstSize = 4;
				default:
					*mainBurstSize = 4;
					tmp = ( hSize / 4 ) % 4;
					*remainedBurstSize = ( tmp ) ? tmp : 4;
					break;
			}
			break;
	}
}



/********************************************************
 CalculatePrescalerRatioShift - none
 
 Description:	
 - none
 
*/
void CalculatePrescalerRatioShift( U32 SrcSize , U32 DstSize , U32* ratio , U32* shift )
{
	if ( SrcSize >= 64 * DstSize )
	{
		Uart_Printf( "ERROR: out of the prescaler range: SrcSize/DstSize = %d(< 64)\n" , SrcSize / DstSize );
		while ( 1 );
	}
	else if ( SrcSize >= 32 * DstSize )
	{
		*ratio = 32;
		*shift = 5;
	}
	else if ( SrcSize >= 16 * DstSize )
	{
		*ratio = 16;
		*shift = 4;
	}
	else if ( SrcSize >= 8 * DstSize )
	{
		*ratio = 8;
		*shift = 3;
	}
	else if ( SrcSize >= 4 * DstSize )
	{
		*ratio = 4;
		*shift = 2;
	}
	else if ( SrcSize >= 2 * DstSize )
	{
		*ratio = 2;
		*shift = 1;
	}
	else
	{
		*ratio = 1;
		*shift = 0;
	}
}


/********************************************************
 CamCaptureStart - Start camera capture operation.
 
 Description:	
 - mode= CAM_CODEC_CAPTURE_ENABLE_BIT or CAM_PVIEW_CAPTURE_ENABLE_BIT or both
  
*/
void CamCaptureStart( U32 mode )
{
	if ( mode & CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT )
	{
		camCodecStatus = CAM_STARTED;
		rCICOSCCTRL |= CAM_CODEC_SACLER_START_BIT;
	}

	if ( mode & CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT )
	{
		camPviewStatus = CAM_STARTED;
		rCIPRSCCTRL |= CAM_PVIEW_SACLER_START_BIT;
	}

	if ( mode & CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT )
	{
		camCodecStatus = CAM_STARTED;
		rCICOSCCTRL |= CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT;
	}

	rCIIMGCPT |= CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT | mode;
}


void CamCaptureStop( void )
{
	camCodecStatus = CAM_STOP_ISSUED;
	camPviewStatus = CAM_STOP_ISSUED;
}


void _CamCodecStopHw( void )
{
	rCICOSCCTRL &= ~CAM_CODEC_SACLER_START_BIT; //stop codec scaler.
	rCIIMGCPT &= ~CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT; //stop capturing for codec scaler.
	if ( !( rCIIMGCPT & CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT ) )
		rCIIMGCPT &= ~CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT; //stop capturing for preview scaler if needed.
	rCICOCTRL |= ( 1 << 2 ); //Enable last IRQ at the end of frame capture.
	//NOTE:LastIrqEn bit should be set after clearing CAPTURE_ENABLE_BIT & SCALER_START_BIT
}

void _CamPviewStopHw( void )
{
	rCIPRSCCTRL &= ~CAM_PVIEW_SACLER_START_BIT; //stop preview scaler.
	rCIIMGCPT &= ~CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT; //stop capturing for preview scaler.
	if ( !( rCIIMGCPT & CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT ) )
		rCIIMGCPT &= ~CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT; //stop capturing for codec scaler if needed.
	rCIPRCTRL |= ( 1 << 2 ); //Enable last IRQ at the end of frame capture.
	//NOTE:LastIrqEn bit should be set after clearing CAPTURE_ENABLE_BIT & SCALER_START_BIT
}


void __irq CamIsr( void )
{
	U32 completedFrameIndex;

	if ( rSUBSRCPND & BIT_SUB_CAM_C )
	{
		Uart_Printf("[C]");
		rGPFDAT ^= 1 << 5;	//hzh
		CamCodecIntMask();
		rSUBSRCPND |= BIT_SUB_CAM_C;
		ClearPending( BIT_CAM );
		switch ( camCodecStatus )
		{
			case CAM_STOP_ISSUED:
				_CamCodecStopHw();
				camCodecStatus = CAM_LAST_CAPTURING;
				Uart_Printf( "cr=%x\n" , rCICOCTRL );
				//Uart_Printf("cS1\n");
				break;
			case CAM_LAST_CAPTURING:
				camCodecStatus = CAM_STOPPED;
				CamCodecIntMask();			
				//Uart_Printf("cS2\n");
				return;
			case CAM_STARTED:
				flagCaptured_C = 1;
				//				_CamCodecStopHw();
				if ( camTestMode & CAM_TEST_MODE_CODEC )
				{
					if ( camCodecCaptureCount > 0 )
						completedFrameIndex = ( ( ( rCICOSTATUS >> 26 ) & 0x3 ) + 4 - 2 ) % 4;   
					//Uart_Printf("FrameIndex:%d\n",completedFrameIndex);
				}
				else
				{
					//Uart_Printf("Just Capturing without display");
				}
				break;
			case CAM_CODEC_SCALER_BYPASS_STATE:
				//Uart_Printf("cBP\n");
				break;
			default:
				break;
		}

		CamCodecIntUnmask();