video_ntsc_pal.c

基于DM642平台的H.264编码器优化代码

/*
 *  Copyright 2003 by Texas Instruments Incorporated.
 *  All rights reserved. Property of Texas Instruments Incorporated.
 *  Restricted rights to use, duplicate or disclose this code are
 *  granted through contract.
 *  
 */
/* "@(#) DDK 1.10.00.23 07-02-03 (ddk-b12)" */

#include <std.h>

#include <tsk.h>  
#include <sem.h>   
#include <gio.h>

#include <csl_dat.h>
#include <csl_cache.h>
#include <csl.h>
#include <csl_edma.h>
#include <sys.h>
#include <log.h>

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

#include <evmdm642.h>

#include "colorbar.h"
#include "evmdm642_vcapparams.h"
#include "evmdm642_vdisparams.h"   
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//#include "time.h"

#define _GLOBAL_
#include "dsp_type.h"
#include "dsp_global.h"
#include "dsp_stream.h"
#include "dsp_vop.h"

//#include "basic_op.h" 
/* heap IDs defined in the BIOS configuration file */
extern Int EXTERNALHEAP;

    FVID_Handle disChan; //设置设备句柄
    FVID_Handle capChan;
    FVID_Frame *capFrameBuf=NULL;
    FVID_Frame *disFrameBuf=NULL;
    
    Int numLinesDis=0 ;
    Int numLinesCap=0;
    Int numLines=0 ;
   
//#ifdef _CAPTURE
    
    Int numPixels =0;
    Int capLinePitch=0 ;
    Int disLinePitch=0 ;
//    clock_t start_T=0,end_T=0,total_T=0;
//#endif 
 
void myImageProcess(int f0);
/*
 * ======== main ========
 */
main()
{
x_dim=720;  // 图像宽度
y_dim =576; // 图像高度
area = x_dim * y_dim;//面积大小
QP=2;// quant step size
search_range=16;// for motion estimation 
time_increment_resolution=30;
prev_rounding_type=0;
malloc_size= area * 3/2 ;
current = (unsigned char *) malloc(malloc_size);
result=(unsigned char *) malloc(malloc_size);
malloc_size = (x_dim+2*16) * (y_dim+2*16)*3/2 ;//参考图像大小
reference = (unsigned char *) malloc(malloc_size);
reconstruct = (unsigned char *) malloc(malloc_size);
g_motion_x = (char *)malloc(x_dim/MB_SIZE * (y_dim/MB_SIZE) * 4 * sizeof(char));   //mot
g_motion_y = (char *)malloc(x_dim/MB_SIZE * (y_dim/MB_SIZE) * 4 * sizeof(char));   //mot
g_MB_Mode = (char *)malloc(x_dim/MB_SIZE * (y_dim/MB_SIZE) * sizeof(char));   //mot
g_DC_store[0] = (short ***)malloc(x_dim/MB_SIZE * sizeof(short **));//DC系数数组
	for (i = 0; i < 45; i++)
	{
		g_DC_store[0][i] = (short **)malloc(6 * sizeof(short *));
		for (j = 0; j < 6; j++)
			g_DC_store[0][i][j] = (short *)malloc(15 * sizeof(short));
	}

	 
	g_DC_store[1] = (short ***)malloc(x_dim/MB_SIZE * sizeof(short **));
	for (i = 0; i < 45; i++)
	{
		g_DC_store[1][i] = (short **)malloc(6 * sizeof(short *));
		for (j = 0; j < 6; j++)
			g_DC_store[1][i][j] = (short *)malloc(15 * sizeof(short));
	}

//	initBuffer();
	pbfr = buffer;
	ByteBfr = 0;
	leftcnt = 8;
	bytecnt = 0;
	p_par = &vop_par;
//	initVopPar();
	p_par->prediction_type=I_VOP;
	p_par->rounding_type=0;
	p_par->width=720;
	p_par->height=576;
	p_par->hor_spat_ref=-16;
	p_par->ver_spat_ref=-16;
	p_par->quantizer=8;
	p_par->intra_quantizer=8;
	p_par->time_increment_resolution=30;
	p_par->sr_for=16;
	p_par->fcode_for=1;
	p_par->quant_precision=5;
	p_par->bits_per_pixel=8;
	p_par->modulo_time_base=0;

    /******************************************************/
    /* 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);//打开数据传输
}

/*
 * ======== tskVideoCAPTURE ========
 * video CAPTURE function.定义任务型中断函数
 */
void tskVideoCapture()
{
    Int status;

    Int frames = 0;
    
    int f0=0;

    numLinesDis = EVMDM642_vDisParamsChan.imgVSizeFld1;
    numLinesCap = EVMDM642_vCapParamsChan.fldYStop1 - EVMDM642_vCapParamsChan.fldYStrt1+1;
    numLines = (numLinesDis > numLinesCap) ? numLinesCap : numLinesDis;
   // char mLaplacian[3*3]={ -1,-1,-1, -1,9,-1,-1,-1,-1};

#ifdef _CAPTURE
      
     numPixels = EVMDM642_vCapParamsChan.fldXStop1 - EVMDM642_vCapParamsChan.fldXStrt1+1;
     capLinePitch = EVMDM642_vCapParamsChan.fldXStop1 - EVMDM642_vCapParamsChan.fldXStrt1+1;
     disLinePitch = EVMDM642_vDisParamsChan.imgHSizeFld1;
    //Int i,ii,j;
#endif                
    
 
    numLines *= 2; /* both fields */
    /******************************************************/
    /* 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                   */
    /******************************************************/
#ifdef _CAPTURE
    capChan = FVID_create("/VP0CAPTURE/A/0", 
            IOM_INPUT, &status, (Ptr)&EVMDM642_vCapParamsChan, NULL);//创建管道
#endif          
    /******************************************************/
    /* 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);//控制函数
#ifdef _CAPTURE
    FVID_control(capChan, VPORT_CMD_EDC_BASE + EDC_CONFIG, 
        (Ptr)&EVMDM642_vCapParamsSAA7115);
  
#endif


    /******************************************************/
    /* start capture & display operation                  */    
    /******************************************************/
    FVID_control(disChan, VPORT_CMD_START, NULL);
#ifdef _CAPTURE
    FVID_control(capChan, VPORT_CMD_START, NULL);//打开管道      
#endif    
    
    /********************************************************/
    /* request a frame buffer from display & capture driver */
    /********************************************************/
    FVID_alloc(disChan, &disFrameBuf);
#ifdef _CAPTURE
    FVID_alloc(capChan, &capFrameBuf); //分配内存空间       
#endif
    frames ++;
    
    while(1)//等待任务
    {/* loop forever */
    if(f0==3) f0=0;
    
#ifdef _CAPTURE
        
        
       
#ifdef _PROCESS  
       
         myImageProcess(f0);
       
#else
        
        for(i = 0; i < numLines; i ++) {

          DAT_copy(capFrameBuf->frame.iFrm.y1 + i * capLinePitch, 
                     disFrameBuf->frame.iFrm.y1 + i * disLinePitch,
                     numPixels);
          DAT_copy(capFrameBuf->frame.iFrm.cb1 + i * (capLinePitch >> 1), 
                     disFrameBuf->frame.iFrm.cb1 + i * (disLinePitch >> 1),
                     numPixels>>1);
          DAT_copy(capFrameBuf->frame.iFrm.cr1 + i * (capLinePitch >> 1), 
                     disFrameBuf->frame.iFrm.cr1 + i * (disLinePitch >> 1),
                     numPixels>>1); 
        }
#endif        
        
   
        DAT_wait(DAT_XFRID_WAITALL);/**/
        FVID_exchange(capChan, &capFrameBuf);//更新内存
 
#else
        fillFrmBuf(&disFrameBuf->frame.iFrm, EVMDM642_vDisParamsChan.imgHSizeFld1,
            EVMDM642_vDisParamsChan.imgVSizeFld1  + 
            EVMDM642_vDisParamsChan.imgVSizeFld2, frames % 360);
#endif
        FVID_exchange(disChan, &disFrameBuf); /**/       
        frames ++;
        f0++;              
   }
}


void myImageProcess(int f0)
{ 
  register Int i;
//   start_T=0,end_T=0,total_T=0;
 //从摄像头获取图像
  for(i = 0; i < numLines; i ++) {

          DAT_copy(capFrameBuf->frame.iFrm.y1 + i * capLinePitch, 
                     current + i * disLinePitch,
                     numPixels);
          DAT_copy(capFrameBuf->frame.iFrm.cb1 + i * (capLinePitch >> 1), 
                     current +x_dim*y_dim + i * (disLinePitch >> 1),
                     numPixels>>1);
          DAT_copy(capFrameBuf->frame.iFrm.cr1 + i * (capLinePitch >> 1), 
                     current +x_dim*y_dim+x_dim*y_dim/4 + i * (disLinePitch >> 1),
                     numPixels>>1); 
        } 
            
     if (f0 == 0) 	p_par->prediction_type=I_VOP;
		else p_par->prediction_type= P_VOP;
		
		if(p_par->prediction_type == P_VOP)
		{
			prev_rounding_type = 1-prev_rounding_type;
			p_par->rounding_type = prev_rounding_type;
		}
        //start_T=clock();
		CodeVop(current,
				reference,
				reconstruct,
				f0);//编码函数
	    //end_T=clock();
	    //total_T=end_T-start_T;
//用于显示图像
for(i = 0; i <x_dim*y_dim-1; i ++) 
   DAT_copy(result + i,disFrameBuf->frame.iFrm.y1 + i,1);
for(i = 0; i <x_dim*y_dim/4-1; i ++) 
   DAT_copy(result +x_dim*y_dim+ i,disFrameBuf->frame.iFrm.cb1 + i,1); 
for(i = 0; i <x_dim*y_dim/4-1; i ++) 
   DAT_copy(result +x_dim*y_dim+x_dim*y_dim/4+i,capFrameBuf->frame.iFrm.cr1 + i,1);
 
 		voptmp = reference;
		reference = reconstruct;
		reconstruct = voptmp;
	}