dm642main.c

基于VPM642的距离变换程序

/********************************************************************/
/*  Copyright 2004 by SEED Incorporated.							*/
/*  All rights reserved. Property of SEED Incorporated.				*/
/*  Restricted rights to use, duplicate or disclose this code are	*/
/*  granted through contract.									    */
/*  															    */
/********************************************************************/
#include <stdio.h>
//#include <std.h>
//#include <csl.h>
#include <csl_emifa.h>
//#include <csl_irq.h>
//#include <csl_chip.h>
#include <time.h>
#include <csl_cache.h>
#include <csl_dat.h>

#include "seeddm642.h"        
        
#define WIDTH   320
#define HEIGHT  240

Uint32  id_InBuffA  = DAT_XFRID_WAITALL,
        id_OutBuffA = DAT_XFRID_WAITALL,
        id_InBuffA1  = DAT_XFRID_WAITALL,
        id_OutBuffA1 = DAT_XFRID_WAITALL;
        

//#pragma DATA_ALIGN(InBuffA, L1D_LINESIZE)
//#pragma DATA_ALIGN(InBuffB, L1D_LINESIZE)
unsigned char ColumnA [WIDTH];
unsigned char ColumnB [WIDTH];
unsigned char ColumnC [WIDTH];
unsigned char Columndst [WIDTH];

unsigned char ColumnA1 [WIDTH];
unsigned char ColumnB1 [WIDTH];
unsigned char ColumnC1 [WIDTH];
unsigned char Columndst1 [WIDTH];
//#pragma DATA_ALIGN(InBuffA, L1D_LINESIZE)
//#pragma DATA_ALIGN(InBuffB, L1D_LINESIZE)
//unsigned char Columnsrc [WIDTH*HEIGHT];
//unsigned char Columndst [WIDTH*HEIGHT];
//unsigned char Columncomp [WIDTH*WIDTH];

/* ------------------------------------------------------------------------ */
/*  Source data to process in external memory                               */
/*  Destination for processed data in external memory                       */
/* ------------------------------------------------------------------------ */
#pragma DATA_SECTION(src,".external")
#pragma DATA_SECTION(dst,".external")
#pragma DATA_SECTION(comp,".external")
unsigned char src[WIDTH*HEIGHT];
unsigned char dst[WIDTH*HEIGHT];
unsigned char comp[WIDTH*HEIGHT];

/*SEEDDM642的emifa的设置结构*/
EMIFA_Config Seeddm642ConfigA ={
	   EMIFA_FMKS(GBLCTL, EK2RATE, HALFCLK)    |
        EMIFA_FMKS(GBLCTL, EK2HZ, CLK)          |
        EMIFA_FMKS(GBLCTL, EK2EN, ENABLE)       |
        EMIFA_FMKS(GBLCTL, BRMODE, MRSTATUS)    |
        EMIFA_FMKS(GBLCTL, NOHOLD, DISABLE)     |
        EMIFA_FMKS(GBLCTL, EK1HZ, HIGHZ)        |
        EMIFA_FMKS(GBLCTL, EK1EN, ENABLE)       |
        EMIFA_FMKS(GBLCTL, CLK4EN, ENABLE)      |
        EMIFA_FMKS(GBLCTL, CLK6EN, ENABLE),
        
        EMIFA_FMKS(CECTL, WRSETUP, DEFAULT)    |
        EMIFA_FMKS(CECTL, WRSTRB, DEFAULT)     |
        EMIFA_FMKS(CECTL, WRHLD, DEFAULT)      |
        EMIFA_FMKS(CECTL, RDSETUP, DEFAULT)    |
        EMIFA_FMKS(CECTL, TA, DEFAULT)         |
        EMIFA_FMKS(CECTL, RDSTRB, DEFAULT)     |
        EMIFA_FMKS(CECTL, MTYPE, SDRAM64)      |
        EMIFA_FMKS(CECTL, RDHLD, DEFAULT),
        
        EMIFA_FMKS(CECTL, WRSETUP, OF(7))      |
        EMIFA_FMKS(CECTL, WRSTRB, OF(14))      |
        EMIFA_FMKS(CECTL, WRHLD, OF(2))        |
        EMIFA_FMKS(CECTL, RDSETUP, OF(2))      |
        EMIFA_FMKS(CECTL, TA, OF(2))           |
        EMIFA_FMKS(CECTL, RDSTRB, OF(14))      |
        EMIFA_FMKS(CECTL, MTYPE, ASYNC8)       |
        EMIFA_FMKS(CECTL, RDHLD, OF(1)),
        
        EMIFA_FMKS(CECTL, WRSETUP, OF(2))      |
        EMIFA_FMKS(CECTL, WRSTRB, OF(10))      |
        EMIFA_FMKS(CECTL, WRHLD, OF(2))        |
        EMIFA_FMKS(CECTL, RDSETUP, OF(2))      |
        EMIFA_FMKS(CECTL, TA, OF(2))           |
        EMIFA_FMKS(CECTL, RDSTRB, OF(10))      |
        EMIFA_FMKS(CECTL, MTYPE, ASYNC32)      |
        EMIFA_FMKS(CECTL, RDHLD, OF(2)),

        EMIFA_FMKS(CECTL, WRSETUP, OF(2))      |
        EMIFA_FMKS(CECTL, WRSTRB, OF(10))      |
        EMIFA_FMKS(CECTL, WRHLD, OF(2))        |
        EMIFA_FMKS(CECTL, RDSETUP, OF(2))      |
        EMIFA_FMKS(CECTL, TA, OF(2))           |
        EMIFA_FMKS(CECTL, RDSTRB, OF(10))      |
        EMIFA_FMKS(CECTL, MTYPE, SYNC32)       |
        EMIFA_FMKS(CECTL, RDHLD, OF(2)),
        
        EMIFA_FMKS(SDCTL, SDBSZ, 4BANKS)       |
        EMIFA_FMKS(SDCTL, SDRSZ, 12ROW)        |
        EMIFA_FMKS(SDCTL, SDCSZ, 8COL)         |
        EMIFA_FMKS(SDCTL, RFEN, ENABLE)        |
        EMIFA_FMKS(SDCTL, INIT, YES)           |
        EMIFA_FMKS(SDCTL, TRCD, OF(1))         |
        EMIFA_FMKS(SDCTL, TRP, OF(1))          |
        EMIFA_FMKS(SDCTL, TRC, OF(5))          |
        EMIFA_FMKS(SDCTL, SLFRFR, DISABLE),
        
        EMIFA_FMKS(SDTIM, XRFR, OF(0))         |
        EMIFA_FMKS(SDTIM, PERIOD, OF(2075)),
        
        EMIFA_FMKS(SDEXT, WR2RD, OF(1))        |
        EMIFA_FMKS(SDEXT, WR2DEAC, OF(3))      |
        EMIFA_FMKS(SDEXT, WR2WR, OF(1))        |
        EMIFA_FMKS(SDEXT, R2WDQM, OF(3))       |
        EMIFA_FMKS(SDEXT, RD2WR, OF(2))        |
        EMIFA_FMKS(SDEXT, RD2DEAC, OF(3))      |
        EMIFA_FMKS(SDEXT, RD2RD, OF(1))        |
        EMIFA_FMKS(SDEXT, THZP, OF(2))         |
        EMIFA_FMKS(SDEXT, TWR, OF(2))          |
        EMIFA_FMKS(SDEXT, TRRD, OF(0))         |
        EMIFA_FMKS(SDEXT, TRAS, OF(6))         |
        EMIFA_FMKS(SDEXT, TCL, OF(1)),           
        
        EMIFA_CESEC_DEFAULT,

        EMIFA_CESEC_DEFAULT,

        EMIFA_CESEC_DEFAULT,

        EMIFA_FMKS(CESEC, SNCCLK, ECLKOUT2)    |
        EMIFA_FMKS(CESEC, RENEN, READ)         |
        EMIFA_FMKS(CESEC, CEEXT, ACTIVE)       |
        EMIFA_FMKS(CESEC, SYNCWL, 0CYCLE)      |
        EMIFA_FMKS(CESEC, SYNCRL, 3CYCLE)
};

//void DistanceTransform_A
//(
//   unsigned char  indata1[], /* Input image     */
//   unsigned char  outdata[],   /* Output image    */
//   int n,                    /* width of input data*/
//   int m                    /* height of input data*/
//);
 

void main()
{
    int i,j,HALFHEIGHT;
    clock_t start;
	clock_t overhead;
	clock_t elapsed;
	
    /* Return lower 8 bits of register */
/*-------------------------------------------------------*/
/* perform all initializations                           */
/*-------------------------------------------------------*/
	//Initialise CSL，初始化CSL库*/
	CSL_init();
/*----------------------------------------------------------*/
	/*EMIFA的初始化，将CE0设为SDRAM空间，CE1设为异步空间
	 注，DM642支持的是EMIFA，而非EMIF*/
	EMIFA_config(&Seeddm642ConfigA);
/*----------------------------------------------------------*/
	
    
    CACHE_setL2Mode(CACHE_0KCACHE);
    
    DAT_open(DAT_CHAANY, DAT_PRI_HIGH, 0);	 
    start = clock();
	overhead = clock()-start;
	HALFHEIGHT=HEIGHT/2;
	/* Calculate the overhead from calling clock() */
	
	for (i=0; i<WIDTH*HEIGHT-1; i++)
    {
       src[i] = i % 256;
       dst[i] = src[i];
       //Columncomp[i]= 3;
    }
    
    DistanceTransform_C(src,comp,WIDTH,HEIGHT);
		
    start = clock();
        
    //前向扫描
    id_InBuffA = DAT_copy(src, ColumnC, WIDTH);
    DAT_wait(id_InBuffA);
    id_InBuffA = DAT_copy(src+WIDTH, ColumnA, WIDTH);
    DAT_wait(id_InBuffA);
    id_InBuffA = DAT_copy(src+WIDTH*2, ColumnB, WIDTH);
    DAT_wait(id_InBuffA);
    DistanceTransformf_L(ColumnC,ColumnA,ColumnB,Columndst,WIDTH,3,4,255);
    
    id_OutBuffA = DAT_copy(Columndst,dst+WIDTH*2+2,WIDTH-4);
    for(j=2;j<WIDTH-2;j++)
    {ColumnB[j]=Columndst[j-2];}
    
    for (i=3; i<HEIGHT-2; i=i+3)
    {
       id_InBuffA = DAT_copy(src+WIDTH*i, ColumnC, WIDTH);
       DAT_wait(id_InBuffA);
       DAT_wait(id_OutBuffA);
       DistanceTransformf_L(ColumnA,ColumnB,ColumnC,Columndst,WIDTH,3,4,255);
       id_OutBuffA = DAT_copy(Columndst,dst+WIDTH*i+2,WIDTH-4);
       for(j=2;j<WIDTH-2;j++)
       {ColumnC[j]=Columndst[j-2];}
       
       
       id_InBuffA = DAT_copy(src+WIDTH*(i+1), ColumnA, WIDTH);
       DAT_wait(id_InBuffA);
       DAT_wait(id_OutBuffA);
       DistanceTransformf_L(ColumnB,ColumnC,ColumnA,Columndst,WIDTH,3,4,255);
       id_OutBuffA = DAT_copy(Columndst,dst+WIDTH*(i+1)+2,WIDTH-4);
       for(j=2;j<WIDTH-2;j++)
       {ColumnA[j]=Columndst[j-2];}
       
       
       id_InBuffA = DAT_copy(src+WIDTH*(i+2), ColumnB, WIDTH);
       DAT_wait(id_InBuffA);
       DAT_wait(id_OutBuffA);
       DistanceTransformf_L(ColumnC,ColumnA,ColumnB,Columndst,WIDTH,3,4,255);
       id_OutBuffA = DAT_copy(Columndst,dst+WIDTH*(i+2)+2,WIDTH-4);
       for(j=2;j<WIDTH-2;j++)
       {ColumnB[j]=Columndst[j-2];}
       
    }
    DAT_wait(id_OutBuffA);
    
    //后向扫描
    id_InBuffA = DAT_copy(dst+(HEIGHT-3)*WIDTH, ColumnC, WIDTH);
    DAT_wait(id_InBuffA);
    id_InBuffA = DAT_copy(dst+(HEIGHT-2)*WIDTH, ColumnA, WIDTH);
    DAT_wait(id_InBuffA);
    id_InBuffA = DAT_copy(dst+(HEIGHT-1)*WIDTH, ColumnB, WIDTH);
    DAT_wait(id_InBuffA);
    DistanceTransformb_L(ColumnC,ColumnA,ColumnB,Columndst,WIDTH,3,4,255);
    id_OutBuffA = DAT_copy(Columndst+4,dst+(HEIGHT-3)*WIDTH+2,WIDTH-4);
    for(j=2;j<WIDTH-2;j++)
    {ColumnC[j]=Columndst[j+2];}
    
    
    for (i=HEIGHT-4; i>0; i=i-3)
    {
       id_InBuffA = DAT_copy(dst+WIDTH*i, ColumnB, WIDTH);
       DAT_wait(id_InBuffA);
       DAT_wait(id_OutBuffA);
       DistanceTransformb_L(ColumnB,ColumnC,ColumnA,Columndst,WIDTH,3,4,255);
       id_OutBuffA = DAT_copy(Columndst+4,dst+WIDTH*i+2,WIDTH-4);
       for(j=2;j<WIDTH-2;j++)
       {ColumnB[j]=Columndst[j+2];}
       
       
       id_InBuffA = DAT_copy(dst+WIDTH*(i-1), ColumnA, WIDTH);
       DAT_wait(id_InBuffA);
       DAT_wait(id_OutBuffA);
       DistanceTransformb_L(ColumnA,ColumnB,ColumnC,Columndst,WIDTH,3,4,255);
       id_OutBuffA = DAT_copy(Columndst+4,dst+WIDTH*(i-1)+2,WIDTH-4);
       for(j=2;j<WIDTH-2;j++)
       {ColumnA[j]=Columndst[j+2];}
       
       
       id_InBuffA = DAT_copy(dst+WIDTH*(i-2), ColumnC, WIDTH);
       DAT_wait(id_InBuffA);
       DAT_wait(id_OutBuffA);
       DistanceTransformb_L(ColumnC,ColumnA,ColumnB,Columndst,WIDTH,3,4,255);
       id_OutBuffA = DAT_copy(Columndst+4,dst+WIDTH*(i-2)+2,WIDTH-4);
       for(j=2;j<WIDTH-2;j++)
       {ColumnC[j]=Columndst[j+2];}
       
    }
    DAT_wait(id_OutBuffA);
    
    elapsed = clock()-start-overhead;
	printf("Time = %ld cycles\n",(long)elapsed);
	
	for (i=0; i<HEIGHT; i++)
	{    
	    for (j=0; j<WIDTH; j++)
	    {
	        if (dst[i*WIDTH+j] != comp[i*WIDTH+j])
	        {
	            printf("Data Mismatch!\n");
	            printf("i=%d , j=%d \n",i,j);
	            DAT_close();
	            exit(0);
	        }
	    }
	}
	//前向扫描比较
    /*for (i=2; i<HEIGHT; i++)
	{    
	    for (j=2; j<WIDTH-2; j++)
	    {
	        if (dst[i*WIDTH+j-2] != comp[i*WIDTH+j])
	        {
	            printf("Data Mismatch!\n");
	            printf("i=%d , j=%d \n",i,j);
	            DAT_close();
	            exit(0);
	        }
	    }
	}*/
	//后向扫描比较
	/*for (i=HEIGHT-3; i>-1; i--)
	{    
	    for (j=2; j<WIDTH-2; j++)
	    {
	        if (dst[i*WIDTH+j+2] != comp[i*WIDTH+j])
	        {
	            printf("Data Mismatch!\n");
	            printf("i=%d , j=%d \n",i,j);
	            DAT_close();
	            exit(0);
	        }
	    }
	}*/
    
    printf("Successfully completed!\n");
	DAT_close();
	/*测试完成*/
    for(;;){}
}