resize.c

dm270 source code

/*
    DM270 ARM Evaluation Software

    (c)Texas Instruments 2003
*/

#include <system/uart270.h>
#include <system/osd270.h>

#include <user/osd.h>
#include <user/armdsp.h>
#include <user/intc.h>

#include <appl/still.h>

#include <dsp/dspsource.h>

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

#include <demo/dm270_demo.h>
#include <demo_gui/demo_gui.h>
#include <demo/mem_alloc.h>

#include <appl/resize.h>

RESIZE_IMAGE_CMD	ResizeCmd;
RESIZE_IMAGE_REPLY	ResizeReply;
static OSD_WinConfigData		vwin0Config_zoom;
static OSD_VideoWinModeData		vwin0Mode_zoom;

void RESIZE_dsp_zoom();

void RESIZE_MENU_run()
{
	char ch;

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

		ch = UI_getInput();

		GUI_slideShowPanelClear();
		GUI_slideShowPanelReset();

		switch(ch) {
			case '0':
				GUI_fileInfoPanelClear();
				return;
			case '1':
				RESIZE_run();	
				break;
			default:
				break;
		}
	}

}


typedef struct{
	Uint16 resample_u;
	Uint16 resample_d;
} ZoomRatio;

void RESIZE_run()
{

	int i, i_limit;
	volatile int j;
	int in_addr_offset;
	Uint16 img_width, img_height, resize_img_width, resize_img_height;

	ZoomRatio zoom_in_ratios[] = {
	   	{11,10}, {12,10}, {13,10}, {14,10}, {15,10}, {16,10}, {17,10},
	    {18,10}, {19,10}, {20,10}, {21,10}, {22,10}, {23,10}, {24,10},
	    {25,10}, {26,10}, /*{27,10},*/ {28,10}, /*{29,10},*/ {30,10}};
	ZoomRatio zoom_out_ratios[] = {
		{ 4,16}, { 5,16}, { 6,16}, { 7,16}, { 4, 8}, { 9,16}, { 3, 5},
	    { 5, 8}, {11,16}, { 7,10}, { 3, 4}, { 4, 5}, {13,16}, { 7, 8},
	    { 9,10}, {15,16}};
  
	STILL_PLAYBACK_run();

  	
  	// Save 720x480 image that is currently in OSD VIDEO WIN0 area
	memcpy ((char*)WORK_AREA_ADDR, (char*)OSD_VIDEO_WIN0_ADDR, 720*480*2);    

	// ZOOM-OUT TESTING
	// Set Resize Parameters
	ResizeCmd.SrcAddrHigh= HIGH_WORD(WORK_AREA_OFFSET);
	ResizeCmd.SrcAddrLow = LOW_WORD(WORK_AREA_OFFSET);
	ResizeCmd.DstAddrHigh= HIGH_WORD(OSD_VIDEO_WIN0_OFFSET);
	ResizeCmd.DstAddrLow = LOW_WORD(OSD_VIDEO_WIN0_OFFSET);
	
	img_width = OSD_RGET(VIDWIN0XL);
	img_height= OSD_RGET(VIDWIN0YL)*2;
	
	ResizeCmd.ImgWidth   = img_width;
	ResizeCmd.ImgHeight  = img_height;

	vwin0Config_zoom.address = (char*)OSD_VIDEO_WIN0_ADDR;
	vwin0Config_zoom.displayMode = OSD_FRAME_MODE;
	vwin0Config_zoom.hzoom   = OSD_NO_ZOOM;
	vwin0Config_zoom.vzoom   = OSD_NO_ZOOM;

	vwin0Mode_zoom.expandFilterEnable = FALSE;
	vwin0Mode_zoom.hexpand = FALSE;
	vwin0Mode_zoom.vexpand = FALSE;
	

	OSD_setVideoWinMode( &vwin0Mode_zoom ); 
	OSD_winEnable( OSD_VID_WIN0, TRUE);

	i_limit = sizeof(zoom_out_ratios)/sizeof(ZoomRatio);
	UART_sendString( UART0, "\r\n\n Resizing demo in progress." );
	UART_sendString( UART0, "\r\n\n This resizing demo uses iMX do the resizing.\r\n" );
	UART_sendString( UART0, "\r\n Downsampling...\r\n" );
	for (i=i_limit-1; i>=0; --i)
	{
		ResizeCmd.Resample_U = zoom_out_ratios[i].resample_u;
		ResizeCmd.Resample_D = zoom_out_ratios[i].resample_d;
		ResizeCmd.DstBuffWidth = (ResizeCmd.ImgWidth*ResizeCmd.Resample_U)/
									ResizeCmd.Resample_D;
		resize_img_width=ResizeCmd.DstBuffWidth;
			
		ResizeCmd.DstBuffWidth = (ResizeCmd.DstBuffWidth+ (Uint16)15)&
									((Uint16)(~15));
		ResizeCmd.DstBuffHeight = (ResizeCmd.ImgHeight*ResizeCmd.Resample_U)/
									ResizeCmd.Resample_D;
		resize_img_height=ResizeCmd.DstBuffHeight;							
		
		OSD_winEnable( OSD_VID_WIN0, FALSE);
		RESIZE_dsp_zoom();
		if (ResizeReply.Status == (Uint16)0xFFFF) 
			continue;
		
		// Save a 160x120 image for zoom in test
		if((ResizeCmd.Resample_U==4)&&(ResizeCmd.Resample_D==16)) {
			{
				int i;
				char *src_addr, *dst_addr;
				Uint32 offset;

				offset = ResizeCmd.DstBuffWidth;
				dst_addr=(char*)WORK_AREA_ADDR+720*480*2;
				src_addr=(char*)OSD_VIDEO_WIN0_ADDR;

				for(i=0;i<resize_img_height;i++) {
					memcpy( dst_addr, src_addr, resize_img_width*2);
					src_addr += offset*2;
					dst_addr += resize_img_width*2;
				}
			}
		}

		vwin0Config_zoom.offset  = ResizeCmd.DstBuffWidth*2;
		vwin0Config_zoom.width   = ResizeReply.EffectiveWidth;
		vwin0Config_zoom.height  = ResizeReply.EffectiveHeight/2;
		vwin0Config_zoom.startX  = (720-vwin0Config_zoom.width)/2;
		vwin0Config_zoom.startY  = (240-vwin0Config_zoom.height)/2;

		OSD_setWinConfig(OSD_VID_WIN0, &vwin0Config_zoom );	
		OSD_winEnable( OSD_VID_WIN0, TRUE);
		sprintf( UART_outBuff, "[%dx%d]-", ResizeReply.EffectiveWidth, ResizeReply.EffectiveHeight );
		UART_sendString( UART0, UART_outBuff );
		TMRDelay(500);
	}
	

	// ZOOM-IN TESTING
	// Set Resize Parameters
	in_addr_offset = WORK_AREA_OFFSET+720*480*2;
	ResizeCmd.SrcAddrHigh= HIGH_WORD(in_addr_offset);
	ResizeCmd.SrcAddrLow = LOW_WORD(in_addr_offset);
	ResizeCmd.DstAddrHigh= HIGH_WORD(OSD_VIDEO_WIN0_OFFSET);
	ResizeCmd.DstAddrLow = LOW_WORD(OSD_VIDEO_WIN0_OFFSET);
	ResizeCmd.ImgWidth   = resize_img_width;
	ResizeCmd.ImgHeight  = resize_img_height;

	i_limit = sizeof(zoom_in_ratios)/sizeof(ZoomRatio);
	UART_sendString( UART0, "\r\n Upsampling...\r\n" );
	for (i=0; i<i_limit; ++i)
	{
		ResizeCmd.Resample_U = zoom_in_ratios[i].resample_u;
		ResizeCmd.Resample_D = zoom_in_ratios[i].resample_d;
		ResizeCmd.DstBuffWidth = (ResizeCmd.ImgWidth*ResizeCmd.Resample_U)/
									ResizeCmd.Resample_D;
		ResizeCmd.DstBuffWidth = (ResizeCmd.DstBuffWidth+ (Uint16)15)&
									((Uint16)(~15));
		ResizeCmd.DstBuffHeight = (ResizeCmd.ImgHeight*ResizeCmd.Resample_U)/
									ResizeCmd.Resample_D;
		
		OSD_winEnable( OSD_VID_WIN0, FALSE);
		RESIZE_dsp_zoom();
		if (ResizeReply.Status == (Uint16)0xFFFF)
		  continue;
		
		vwin0Config_zoom.offset  = ResizeCmd.DstBuffWidth*2;
		vwin0Config_zoom.width   = ResizeReply.EffectiveWidth;
		vwin0Config_zoom.height  = ResizeReply.EffectiveHeight/2;
		vwin0Config_zoom.startX  = (720-vwin0Config_zoom.width)/2;
		vwin0Config_zoom.startY  = (240-vwin0Config_zoom.height)/2;
		
		OSD_setWinConfig(OSD_VID_WIN0, &vwin0Config_zoom );	
		OSD_winEnable( OSD_VID_WIN0, TRUE);
		sprintf( UART_outBuff, "[%dx%d]-", ResizeReply.EffectiveWidth, ResizeReply.EffectiveHeight );
		UART_sendString( UART0, UART_outBuff );
		TMRDelay(500);
	}
	UART_sendString( UART0, "\r\n Resizing demo complete.\r\n" );
}

void RESIZE_dsp_zoom()
{
  	// start resize on DSP side
	{
		Uint16 cmd;

		// reset DSP
		DSPC_reset();

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

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

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

		// clear DSP HINT interrupt
		INTC_clearIRQ( INT_DSP );

		// send command to start image pipe
		profile_clear(0);
		profile_start(0);
		ARMDSP_sendDspCmd(RESIZE_IMAGE, (Uint16*)&ResizeCmd, sizeof(RESIZE_IMAGE_CMD)/2);

		// wait for resize to complete
		INTC_waitForInt(INT_DSP, 0);
		profile_end(0);
		// get execution status
		ARMDSP_getDspReply(&cmd, (Uint16*)&ResizeReply, sizeof(RESIZE_IMAGE_REPLY)/2 );

		if(    (cmd & 0xFFF) != RESIZE_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 : Resize Image. Execution status [0x%x] \r\n",
				cmd );
			UART_sendString( UART0,  UART_outBuff );
		}
	}

}