video.c

基于dsp的图像重现

#include <std.h>  //DSP/BIOS head file
#include <tsk.h>  
#include <sem.h>   
#include <gio.h>

#include <stdio.h>
//#include <stdafx.h>

#include <csl_dat.h> //CSL head file
#include <csl_cache.h>


#include <fvid.h>   //fvid head file
#include <edc.h>
#include <vport.h>
#include <vportcap.h>
#include <vportdis.h>
#include <saa7105.h>
#include <saa7115.h>    

#include "evmdm642.h"
#include "evmdm642_vcapparams.h"
#include "evmdm642_vdisparams.h"
#include "myvgacfg.h"

#include "algorithm.h"

#define AREA(RECT) (fabs((rect.bottom-rect.top)*(rect.left-rect.right)))

extern Int EXTERNALHEAP;
static const  short coeffs[5] = {0x2543, 0x3313, -0x0C8A, -0x1A04, 0x408D}; //transfer matrix

void tskVideoLoopback();

main()
{
    /******************************************************/
    /* open CSL DAT module for fast copy                  */
    /******************************************************/
    CSL_init();                                             
    CACHE_clean(CACHE_L2ALL, 0, 0);
    CACHE_setL2Mode(CACHE_256KCACHE);       
    CACHE_enableCaching(CACHE_EMIFA_CE00);
    CACHE_enableCaching(CACHE_EMIFA_CE01);
    DAT_open(DAT_CHAANY, DAT_PRI_LOW, DAT_OPEN_2D);
 
}

    
    
void tskVideoLoopback()
{
    //initial display params
    Int status;
    FVID_Handle disChan; 
    FVID_Frame *disFrameBuf;
    Int numLinesDis = EVMDM642_vDisParamsChan.imgVSizeFld1;
    Int numLinesCap = EVMDM642_vCapParamsChan.fldYStop1 -
       EVMDM642_vCapParamsChan.fldYStrt1+1;

    
    Int numLines = (numLinesDis > numLinesCap) ? numLinesCap : numLinesDis;
    
    //initial capture params
    Int i,j;
    FVID_Handle capChan; 
    Int numPixels = EVMDM642_vCapParamsChan.fldXStop1 - 
       EVMDM642_vCapParamsChan.fldXStrt1+1;
    FVID_Frame *capFrameBuf;
    Int capLinePitch = EVMDM642_vCapParamsChan.fldXStop1 - 
       EVMDM642_vCapParamsChan.fldXStrt1+1;
    Int disLinePitch = EVMDM642_vDisParamsChan.imgHSizeFld1;
    
    //图像数组定义
    Byte *temp[3];
    Byte *BinaryImage;
    Size size;
    Byte *dst;
    
    
   
    int  maxcomponent=0;
    int  counter[200];
    int  base=1;
    Rect rect,recttemp;
        
                     
    temp[0]=(Byte *) malloc (sizeof(Byte)*720*288*2);
    temp[1]=(Byte *) malloc (sizeof(Byte)*720*288);
    temp[2]=(Byte *) malloc (sizeof(Byte)*720*288);
          
    
    
    dst=(Byte *) malloc (sizeof(unsigned int)*720*288*2);

    BinaryImage = (Byte *) malloc (sizeof(Byte)*720*288*2);    
    
    numLines *= 2; /* both fields */
    size.cy=numLines;
    size.cx=capLinePitch;
    
    /******************************************************/
    /* allocate both capture and display frame buffers    */
    /* in external heap memory                            */
    /******************************************************/
        EVMDM642_vCapParamsChan.segId = EXTERNALHEAP;
        EVMDM642_vDisParamsChan.segId = EXTERNALHEAP;
        EVMDM642_vDisParamsSAA7105.hI2C = EVMDM642_I2C_hI2C;
        EVMDM642_vCapParamsSAA7115.hI2C = EVMDM642_I2C_hI2C;
        
        
    /******************************************************/
    /* initialization of capture driver                   */
    /******************************************************/
    capChan = FVID_create("/VP0CAPTURE/A/0", 
            IOM_INPUT, &status, (Ptr)&EVMDM642_vCapParamsChan, NULL);
            
    /******************************************************/
    /* initialization of display driver                   */
    /******************************************************/
    disChan = FVID_create("/VP2DISPLAY", IOM_OUTPUT, 
        &status, (Ptr)&EVMDM642_vDisParamsChan, NULL);
        
       /******************************************************/
    /* configure video encoder & decoder                  */
    /******************************************************/
    FVID_control(disChan, VPORT_CMD_EDC_BASE + EDC_CONFIG, 
        (Ptr)&EVMDM642_vDisParamsSAA7105);

    FVID_control(capChan, VPORT_CMD_EDC_BASE + EDC_CONFIG, 
        (Ptr)&EVMDM642_vCapParamsSAA7115);
        
    /******************************************************/
    /* start capture & display operation                  */    
    /******************************************************/
    FVID_control(disChan, VPORT_CMD_START, NULL);
    FVID_control(capChan, VPORT_CMD_START, NULL);
    
    /********************************************************/
    /* request a frame buffer from display & capture driver */
    /********************************************************/
    FVID_alloc(disChan, &disFrameBuf);
    FVID_alloc(capChan, &capFrameBuf);
    
    
    
    
    while(1){/* loop forever */

        /* copy data from capture buffer to display buffer */
        /***************************************************/
        
        memcpy (temp[0],capFrameBuf->frame.iFrm.y1,sizeof(Byte)*720*288*2);
        memcpy (temp[1],capFrameBuf->frame.iFrm.cb1,sizeof(Byte)*720*288);
        memcpy (temp[2],capFrameBuf->frame.iFrm.cr1,sizeof(Byte)*720*288);
        
        memset (dst,0,sizeof(Byte)*720*288*2);   
        memset (BinaryImage,0,sizeof(Byte)*720*288*2);
        //add algorithm here
    
      for (i=0;i<200;i++)
         counter[i]=0;
    
       //get binary iamge          
       getBinaryImage(temp[0],temp[1],temp[2],BinaryImage,size);
       
       //find the connect area; 
       maxcomponent = findConnectComp(BinaryImage,dst,size,counter);
       
     
       recttemp.left =0;
       recttemp.right =0;
       recttemp.bottom =0;
       recttemp.top=0;
       base=0;
       for (base=0;base<maxcomponent;base++)
       {   	
           while(counter[base]==0&&base<maxcomponent)
	          	base++;
		   if(counter[base]>200)
	     {
           rect=Swell1(dst,size,base);
         }
       
              
       if(AREA(rect)>400 && ((rect.right-rect.left)<8*(rect.bottom-rect.top)
                   &&8*(rect.right-rect.left)>(rect.bottom-rect.top))
				   &&rect.right>(rect.left+10))
	     {
	          recttemp = rect;
	     } 
       
       
      for ( i = recttemp.top; i< recttemp.bottom ; i++)
          for (j = recttemp.left;j < recttemp.right; j++)
            {
               temp[0][i*capLinePitch+j] = 0;
                          
            }  
        
       }
         /*for(i=0;i<size.cy;i++)
           for(j=0;j<(size.cx);j++)
            {
              if(dst[i*size.cx+j]!=0)
                 temp[0][i*size.cx+j]=0;
               
            }*/
    
        //transefer YUV mode to rbg565 mode
        for(i = 0; i < numLines; i++) 
        {
            yc2rgb16(coeffs, temp[0] + i * (capLinePitch),
                 temp[1]+ (capLinePitch >> 1) * i, 
                temp[2] + (capLinePitch >>1 ) * i, 
                disFrameBuf->frame.rpFrm.buf + (disLinePitch <<1) * i, 
                numPixels);
        }
     
        FVID_exchange(capChan, &capFrameBuf);
        
        //send to disChan for display
        
        
        
        CACHE_clean(CACHE_L2ALL, 0, 0);
        FVID_exchange(disChan, &disFrameBuf); 
        
                  
   }
}