still.c

dm270 source code

/*
    DM270 ARM Evaluation Software

    (c)Texas Instruments 2003
*/

#include <system/armsys270.h>
#include <system/uart270.h>
#include <system/ccdc270.h>
#include <system/prev270.h>
#include <system/osd270.h>
#include <system/tmr270.h>
#include <system/clkc270.h>

#include <user/ccdm_3d3.h>
#include <user/ccdm.h>
#include <user/ccdc.h>
#include <user/prev.h>
#include <user/osd.h>
#include <user/armdsp.h>

#include <appl/still.h>

#include <h3a/aewb.h>
#include <h3a/af_demo.h>

#include <dsp/dspsource.h>

#include <demo/mem_alloc.h>
#include <demo/menu.h>
#include <demo/ui.h>
#include <demo/exif.h>


#include <util/file_name_gen.h>

#include <demo/dm270_demo.h>

#include <fileio/fileio.h>

#include <demo_gui/demo_gui.h>

CAPTURE_IMAGE_CMD	CaptureImageCmd;
CAPTURE_IMAGE_REPLY CaptureImageReply;

JPEG_ENCODE_CMD		JpegEncCmd;
JPEG_ENCODE_REPLY   JpegEncReply;
JPEG_DECODE_CMD		JpegDecCmd;
JPEG_DECODE_REPLY   JpegDecReply;

STILL_CTRL StillCtrl;

STATUS STILL_init() {
	CaptureImageCmd.RawAddrHigh			= HIGH_WORD(CCD_RAW_DATA_OFFSET);
	CaptureImageCmd.RawAddrLow			= LOW_WORD (CCD_RAW_DATA_OFFSET);
	CaptureImageCmd.JpegAddrHigh		= HIGH_WORD(JPEG_DATA_OFFSET);
	CaptureImageCmd.JpegAddrLow			= LOW_WORD (JPEG_DATA_OFFSET);
	CaptureImageCmd.MaxFileSizeHigh		= HIGH_WORD(JPEG_DATA_MAX_SIZE);
	CaptureImageCmd.MaxFileSizeLow	 	= LOW_WORD (JPEG_DATA_MAX_SIZE);
	CaptureImageCmd.ImgWidth	       	= CCDM_3D3_RAW_DATA_WIDTH_FINE_MODE;			// user/ccdm_3d3.h
	CaptureImageCmd.ImgHeight		   	= CCDM_3D3_RAW_DATA_HEIGHT_FINE_MODE;			// user/ccdm_3d3.h
	CaptureImageCmd.EffWidth	       	= CCDM_3D3_RAW_DATA_WIDTH_FINE_MODE & 0xFF00;
	CaptureImageCmd.EffHeight       	= CCDM_3D3_RAW_DATA_HEIGHT_FINE_MODE & 0xFF00;
	CaptureImageCmd.ColorFormat     	= 0x0004;
	CaptureImageCmd.Interval        	= 0x0000;
	CaptureImageCmd.YQtbladdr       	= 0x0000;
	CaptureImageCmd.UVQtbladdr      	= 0x0000;
	CaptureImageCmd.BGain           	= 0x0320;
	CaptureImageCmd.RGain           	= 0x03e0;
	CaptureImageCmd.ContrMin        	= 0x0020;
	CaptureImageCmd.ContrSlope      	= 0x0300;
	CaptureImageCmd.CompQuality     	= 0x0080;
	CaptureImageCmd.Csat_u          	= 0x0200;
	CaptureImageCmd.Csat_v          	= 0x0200;
	CaptureImageCmd.EdgeThres       	= 0x0100;
	CaptureImageCmd.EdgeGain        	= 0x0008;
	CaptureImageCmd.EdgeColorGain   	= 0x0200;
	CaptureImageCmd.GGain           	= 0x01e0;
	CaptureImageCmd.BlackLevelRed   	= 0x0004;
	CaptureImageCmd.BlackLevelGreen 	= 0x0004;
	CaptureImageCmd.BlackLevelBlue  	= 0x0008;
	CaptureImageCmd.Contrast        	= 0x02A0;
	CaptureImageCmd.Bright          	= 0x000a;

	// JpegEncCmd is for compressing the thumbnail into JPEG
	JpegEncCmd.JpegAddrHigh				= HIGH_WORD(THUMB_JPEG_DATA_OFFSET);
	JpegEncCmd.JpegAddrLow				= LOW_WORD(THUMB_JPEG_DATA_OFFSET);
	JpegEncCmd.RingBuffSizeHigh			= HIGH_WORD(0x7FFFFFF);
	JpegEncCmd.RingBuffSizeLow			= LOW_WORD(0x7FFFFFF);
	JpegEncCmd.ImageAddrHigh			= HIGH_WORD(THUMB_RAW_DATA_OFFSET);
	JpegEncCmd.ImageAddrLow				= LOW_WORD(THUMB_RAW_DATA_OFFSET);
	JpegEncCmd.ImageWidth				= 128;		// multiple of 16
	JpegEncCmd.ImageHeight				= 96;	 	// multiple of 16
	JpegEncCmd.ImageFormat				= 0;		// 4:2:2
	JpegEncCmd.EncFormat				= 3;		// 4:2:2
	JpegEncCmd.RestartMakerInterval		= 0;
	JpegEncCmd.QFactor					= 128;
	
	JpegDecCmd.JpegAddrHigh				= HIGH_WORD(JPEG_DATA_OFFSET);
	JpegDecCmd.JpegAddrLow				= LOW_WORD (JPEG_DATA_OFFSET);
	JpegDecCmd.RingBuffSizeHigh  		= 0xffff;
	JpegDecCmd.RingBuffSizeLow   		= 0xffff;
	JpegDecCmd.MaxJpegSizeHigh   		= 0xffff;
	JpegDecCmd.MaxJpegSizeLow    		= 0xffff;
	JpegDecCmd.VideoAddrHigh     		= HIGH_WORD(CCD_RAW_DATA_OFFSET);
	JpegDecCmd.VideoAddrLow      		= LOW_WORD (CCD_RAW_DATA_OFFSET);
	JpegDecCmd.DecMcuHigh       		= 0xffff;
	JpegDecCmd.DecMcuLow         		= 0xffff;
	JpegDecCmd.ScaleFactor       		= 0x0008;
	JpegDecCmd.HeaderAnalysisFlag		= 0x0001;
	JpegDecCmd.DisplayWidth      		= 768;
	JpegDecCmd.DisplayHeight     		= 576;
	JpegDecCmd.StartX            		= 0;
	JpegDecCmd.StartY            		= 0;


	StillCtrl.SlideShowTmrID			= TMR_3;
	StillCtrl.SlideShowDelay			= 3;

	return E_PASS;
}

void STILL_MENU_run() {
	char ch;

	while(1) {
		UART_sendString( UART0, still_menu );

		ch = UI_getInput();

		GUI_slideShowPanelClear();
		GUI_slideShowPanelReset();

		switch(ch) {
			case '0':
				GUI_fileInfoPanelClear();
				return;
			case '1':
				DraftPreview(TRUE);
				break;
			case '2':
				STILL_CAPTURE_run(FALSE, FALSE, FALSE);	
				break;
			case '3':
				STILL_CAPTURE_run(FALSE, TRUE, TRUE);
				break;
			case '4':
				STILL_CAPTURE_run(TRUE, TRUE, TRUE);
				break;
			case '5':
				STILL_PLAYBACK_MENU_run();
				CLKC_moduleSelectClockSource(CLK_CCDC, CLKC_PCLK );
				break;
			case '6':
				STILL_PLAYBACK_SLIDESHOW_run();
				CLKC_moduleSelectClockSource(CLK_CCDC, CLKC_PCLK );
				break;
			default:
				break;
		}
	}
}


void STILL_PLAYBACK_SLIDESHOW_run() {
	char ch;

	GUI_slideShowPanelClear();
	GUI_slideShowPanelReset();

	if(FS_FILE_IO != TRUE) {
		UART_sendString( UART0, "\r\n\n SDRAM Data storage mode. Cannot do Slide Show. \r\n" );
		return;
	}

	GUI_slideShowPanelDraw();

	StillCtrl.SlideShowPause = FALSE;
	StillCtrl.SlideShowForward = TRUE;
	StillCtrl.SlideShowWait = FALSE;
	STILL_SLIDESHOW_TIMER_init();

	UART_sendString( UART0, still_playback_slideshow_menu );
	while(1) {
		ch = UI_checkInput();

		switch(ch) {
			case '0':
				STILL_SLIDESHOW_TIMER_stop();
				GUI_slideShowPanelClear();
				GUI_slideShowPanelReset();
				return;
			case '1':
				StillCtrl.SlideShowPause = !StillCtrl.SlideShowPause;
				if(StillCtrl.SlideShowPause) {
					UART_sendString( UART0, still_playback_slideshow_menu );
					UART_sendString( UART0, "\r\n\n Slide Show Paused.");
				}
				else
					UART_sendString( UART0, "\r\n Slide Show Resumed.");
				break;
			case '2':
				StillCtrl.SlideShowForward = !StillCtrl.SlideShowForward;
				if(StillCtrl.SlideShowForward)
					UART_sendString( UART0, "\r\n Slide Show Forward Direction.");
				else
					UART_sendString( UART0, "\r\n Slide Show Backward Direction.");
				break;
			default:
				break;
		}
		if(StillCtrl.SlideShowWait == FALSE) {
			if(StillCtrl.SlideShowPause == FALSE ) {
				if(StillCtrl.SlideShowForward) {
					GUI_slideShowPanelSetState(&SLIDESHOW_BUTTON_NEXT);
					STILL_nextFile();
				} else {
					GUI_slideShowPanelSetState(&SLIDESHOW_BUTTON_PREV);
					STILL_prevFile();
				}
				STILL_SLIDESHOW_TIMER_start();
				STILL_PLAYBACK_run();
				UART_sendString( UART0, still_playback_slideshow_menu );
			}
		}
	}
}

static Uint32 SlideShowCurDelay;

void STILL_SLIDESHOW_TIMER_init() {
	TMR_ConfigData slideShowTmr;

	STILL_SLIDESHOW_TIMER_stop();
	
	slideShowTmr.mode		= TMR_FREE_RUN;
	slideShowTmr.prescalar	= 1000;
	slideShowTmr.div		= 27000;
	slideShowTmr.referenceClock = TMR_REF_CLK_PLLIN;

	TMR_setConfig(StillCtrl.SlideShowTmrID, &slideShowTmr);

	INTCAttachISR((INT_ID)StillCtrl.SlideShowTmrID, STILL_SLIDESHOW_TIMER_isr);
}

void STILL_SLIDESHOW_TIMER_stop() {
	TMR_stop(StillCtrl.SlideShowTmrID);
	INTC_enable((INT_ID)StillCtrl.SlideShowTmrID, FALSE);
	INTCDetachISR((INT_ID)StillCtrl.SlideShowTmrID);
}

void STILL_SLIDESHOW_TIMER_isr() {
	SlideShowCurDelay++;
	if(SlideShowCurDelay>=StillCtrl.SlideShowDelay) {
		StillCtrl.SlideShowWait = FALSE;
	}
}

void STILL_SLIDESHOW_TIMER_start() {
	INTC_enable((INT_ID)StillCtrl.SlideShowTmrID, FALSE);
	SlideShowCurDelay = 0;
	StillCtrl.SlideShowWait = TRUE;
	INTC_enable((INT_ID)StillCtrl.SlideShowTmrID, TRUE);
}

void STILL_PLAYBACK_MENU_run() {
	char ch;

	GUI_slideShowPanelClear();
	GUI_slideShowPanelReset();
	GUI_slideShowPanelDraw();

	STILL_PLAYBACK_run();
	while(1) {
		UART_sendString( UART0, still_playback_menu );

		ch = UI_getInput();

		switch(ch) {
			case '0':
				GUI_slideShowPanelClear();
				GUI_slideShowPanelReset();
				return;
			case '1':
				DraftPreview(TRUE);
				break;
			case '2':
				GUI_slideShowPanelSetState(&SLIDESHOW_BUTTON_PREV);
				STILL_prevFile();
				STILL_PLAYBACK_run();
				break;
			case '3':
				GUI_slideShowPanelSetState(&SLIDESHOW_BUTTON_NEXT);
				STILL_nextFile();
				STILL_PLAYBACK_run();
				break;
			case '4':
				STILL_PLAYBACK_run();
				break;
			case '5':
				RESIZE_MENU_run();
				break;
			default:
				break;
		}
	}
}

static PREV_ConfigData	prevConfig_createThumbnail = {
	FALSE,							// ccdcInputWidth8bits;
	FALSE,							// alawEnable;
	TRUE,							// oneShotEnable;
	FALSE,							// resizeOnlyEnable;
	TRUE,							// sdramInputEnable;
	FALSE,							// burstAlignModeEnable;
	FALSE,							// writeEnableValid;
	(char*)CCD_RAW_DATA_ADDR,		// *readAddress;
	(char*)THUMB_RAW_DATA_ADDR,		// *writeAddress;
	CCDM_3D3_RAW_DATA_WIDTH_FINE_MODE,		// hstart;
	1,								// vstart;
	CCDM_3D3_RAW_DATA_WIDTH_FINE_MODE,		// inputPixelsH;
	CCDM_3D3_RAW_DATA_HEIGHT_FINE_MODE,		// inputLinesV;
	128,							// outputPixelsH;
	96								// outputLinesV;
};

void STILL_CAPTURE_run(BOOL enableAF, BOOL enableAE, BOOL enableAWB ) {
	Uint32 jpegSize, thumbSize;
	Uint8 *jpg_addr, *thumb_addr, *exif_addr, *out_addr;
	Uint32 jpg_size, thumb_size, exif_size, out_size;
	EXIFParams prmExif;
	Uint32 maxFileSize;

	UART_sendString( UART0, "\r\n\n Capturing Image. Please wait ... " );

	// stop AE/AWB
	AEWBDemoStop();

	if(enableAF) {
		// perform AF
		DraftPreview(FALSE);
		AFDemoExecute( 3, 0);
	}

	// stop OSD, CCDC, PREV, AEWB
	OSD_winEnable( OSD_VID_WIN0, FALSE );
	CCDC_enable( FALSE, FALSE );
	PREV_enable( FALSE );

	// Init CCD module, CCDC, PREV with fine mode settings
	CCDM_init  (CCDM_3D3, CCDM_FINE_MODE);
	CCDCSetMode(CCDM_3D3, CCDM_FINE_MODE);
	PREVSetMode(CCDM_3D3, CCDM_FINE_MODE);

	PREV_setReadAddr( (char*)CCD_RAW_DATA_ADDR);
	PREV_setWriteAddr( (char*)OSD_VIDEO_WIN0_ADDR);

	if(enableAE) {
		// init CCD module with AE latest results
		CCDM_3D3_tgInit(CCDM_FINE_MODE, aeret.AeLevelCapture);
	}

	if(enableAWB) {
		// init PREV with AWB latest results
		PREV_FSET( WBGAIN0, WG01, awbret.AwbBgainPreview+awbprm.AwbBCompValueCapture );
		PREV_FSET( WBGAIN1, WG03, awbret.AwbRgainPreview+awbprm.AwbRCompValueCapture );
	}

	// setup OSD
	OSDSetMode( OSD_VID_WIN0, VID_640x480, (char*)OSD_VIDEO_WIN0_ADDR);

	// get raw data
	CCDCGetFrame( (char*)CCD_RAW_DATA_ADDR, INT_VD0, 3);

	// generate post-capture view image
	PREV_enable(TRUE);

	// start image pipe on DSP side
	{
		Uint16 cmd;

		

		// reset DSP
		DSPC_reset();

		// clear ARM-DSP communication area
		ARMDSP_clearReg();

		// load image pipe code to DSP side
		DSPLoadCode(ti_image_pipe);

		// wait for DSP to be ready
		do {
			ARMDSP_getArmCmd(&cmd, NULL, 0);
		} while( cmd != 0x777 ) ;

		// clear DSP HINT interrupt
		INTC_clearIRQ( INT_DSP );

		if(enableAWB) {
			// set AWB parameters
			CaptureImageCmd.BGain = awbret.AwbBgainCapture;
			CaptureImageCmd.RGain = awbret.AwbRgainCapture;
		}

		// send command to start image pipe
		ARMDSP_sendDspCmd(CAPTURE_IMAGE, (Uint16*)&CaptureImageCmd, sizeof(CaptureImageCmd)/2);

		if( FS_FILE_IO ) {
			/* while DSP is doing image pipe, check free space on CF or MMCSD */
			maxFileSize = FS_diskFree(FileDevice);
		}

		// wait for image pipe to complete
		INTC_waitForInt(INT_DSP, 0);

		// get execution status
		ARMDSP_getDspReply(&cmd, (Uint16*)&CaptureImageReply, sizeof(CaptureImageReply)/2 );

		if(    (cmd & 0xFFF) != CAPTURE_IMAGE  
			|| (cmd & DSP_CMD_COMPLETE ) != DSP_CMD_COMPLETE 
			|| (cmd & DSP_CMD_INVALID_CMD ) || (cmd & DSP_CMD_INVALID_PARAM ) ) 
		{
			sprintf( UART_outBuff, "\r\n E_DEVICE : Image Capture. Execution status [0x%x] \r\n",
				cmd );
			UART_sendString( UART0,  UART_outBuff );
		}
	}

	jpegSize = MAKE_WORD32(CaptureImageReply.FileSizeHigh, CaptureImageReply.FileSizeLow)+KB;
	sprintf( UART_outBuff, "\r\n JPEG image size is %ld bytes.", jpegSize );
	UART_sendString( UART0,  UART_outBuff );

	// wait for preview to complete post-capture view image
	INTC_waitForInt( INT_PREV, 0);