main.c

gm8120的video控制

        else if (!strcasecmp(cmd, "alarm_idx1"))
        {
            get_arg(arg, sizeof(arg), &p);
            mval.alarm_idx1 = atoi(arg);

        }
        else if (!strcasecmp(cmd, "mv_th2")) 
        {
            get_arg(arg, sizeof(arg), &p);
            mval.mv_th2 = atoi(arg);

        }
        else if (!strcasecmp(cmd, "sad_th2")) 
        {
            get_arg(arg, sizeof(arg), &p);
            mval.sad_th2 = atoi(arg);

        } 
        else if (!strcasecmp(cmd, "dev_th2")) 
        {
            get_arg(arg, sizeof(arg), &p);
            mval.dev_th2 = atoi(arg);

        }
        else if (!strcasecmp(cmd, "alarm_idx2"))
        {
            get_arg(arg, sizeof(arg), &p);
            mval.alarm_idx2 = atoi(arg);

        }  
        else if (!strcasecmp(cmd, "PictureEnable"))
        {
            get_arg(arg, sizeof(arg), &p);
            mval.alarm_picture_enable = atoi(arg);
        }        
     
        else if (!strcasecmp(cmd, "PictureFilename"))
        {
            get_arg(arg, sizeof(arg), &p);
            strcpy(mval.alarm_picture_filename,arg);
        }  
        
        else if (!strcasecmp(cmd, "VideoEnable"))
        {
            get_arg(arg, sizeof(arg), &p);
            mval.alarm_video_enable = atoi(arg);
        }        
        else if (!strcasecmp(cmd, "VideoPostINum"))
        {
            get_arg(arg, sizeof(arg), &p);
            mval.alarm_video_PostINum = atoi(arg);
        }        
        else if (!strcasecmp(cmd, "VideoPreINum"))
        {
            get_arg(arg, sizeof(arg), &p);
            mval.alarm_video_PreINum = atoi(arg);
        }
        else if (!strcasecmp(cmd, "VideoFilename"))
        {
            get_arg(arg, sizeof(arg), &p);
            strcpy(mval.alarm_video_filename,arg);
        }  
        else if (!strcasecmp(cmd, "FTPalarm"))
        {
            get_arg(arg, sizeof(arg), &p);
            mval.FTPalarm = atoi(arg);
        }  
        else if (!strcasecmp(cmd, "MAILalarm"))
        {
            get_arg(arg, sizeof(arg), &p);
            mval.MAILalarm = atoi(arg);
        }  
#if 0
        else if (!strcasecmp(cmd, "timesuffix"))
        {
            get_arg(arg, sizeof(arg), &p);
            mval.timesuffix = atoi(arg);
        }                    
#endif
    }
    return 1;
}






void motion_alarm_init(FMP4_ENC_PARAM *enc_param, struct mcfg mval)
{
	
}
void motion_alarm_action(Faraday_ENC_FRAME *enc_frame,int width,int height,char *data0,char *data1,char *data2)
{
    pid_t           gpid;

    frm_count++;


//printf("#### %d,%d>%d (%d,%d,%d) vs (%d,%d,%d)\n",(enc_frame->frameindex%mval.md_interval),frm_count,(fFrameRate*WORK_FRAMERATE),enc_frame->active0,enc_frame->active1,enc_frame->active2,mval.alarm_idx0,mval.alarm_idx1,mval.alarm_idx2);

    if(((enc_frame->frameindex%mval.md_interval)==0)&&(frm_count>(fFrameRate*WORK_FRAMERATE)))
    {
//printf("<Motion,%d,%d,%s>\n",mval.alarm_video_enable,mval.alarm_picture_enable,mval.alarm_picture_filename,mval.alarm_video_filename);
//printf("#### %d,%d>%d (%d,%d,%d) vs (%d,%d,%d)\n",(enc_frame->frameindex%mval.md_interval),frm_count,(fFrameRate*WORK_FRAMERATE),enc_frame->active0,enc_frame->active1,enc_frame->active2,mval.alarm_idx0,mval.alarm_idx1,mval.alarm_idx2);
	    if((enc_frame->active0>mval.alarm_idx0)||(enc_frame->active1>mval.alarm_idx1)||(enc_frame->active2>mval.alarm_idx2))
	    {
printf("<DO Alarm>\m");
		    frm_count=0;
            if((gpid=fork())<0)
                printf("fork error");
            else if(gpid==0)
            {
                if(mval.alarm_video_enable)
                    do_alarm_video(mval.alarm_picture_filename,mval.pid,width,height,data0,data1,data2);
                if(mval.alarm_picture_enable)
                    do_alarm_picture(mval.alarm_picture_filename,mval.pid,width,height,data0,data1,data2);
                if(mval.pid!=0)
                    kill(mval.pid,SIGALRM);
                exit(0);
            }
            
		    if(waitpid(gpid,NULL,0)<0)
		        printf("wait error");
        }
    }
}



void external_exit(int sig)
{
	//kevin 2006.10.15
	stop_encode = 1;
	usleep(200000);
	enc_close(&video_setting);
	free(out_virt_buffer);
	close(video_fd);
	printf("Frame encoding is done.\n");


	exit(0);	
}


int enc_init(video_profile *avctx)
{
    FMP4_ENC_PARAM  enc_param;
    int             err;

    if(fmpeg4_enc_fd == 0)
	    fmpeg4_enc_fd = open( FMPEG4_ENCODER_DEV,O_RDWR );
	
    if(fmpeg4_enc_fd == 0)
    {
	printf("Fail to open %s\n",FMPEG4_ENCODER_DEV);
	return -1;
    }    

#ifdef NEW_VERSION

    //mmap_addr = mmap(0, (avctx->width * avctx->height * 3) / 2,PROT_READ|PROT_WRITE,MAP_SHARED,fmpeg4_enc_fd, 0);
    //if(mmap_addr <= 0)
      //  return -1;

	enc_param.u32BitRate=avctx->bit_rate;
	enc_param.u32FrameWidth=avctx->width;
	enc_param.u32FrameHeight=avctx->height;
	enc_param.fFrameRate=(float)avctx->framerate/(float)avctx->frame_rate_base;
	fFrameRate=enc_param.fFrameRate;
    enc_param.u32InitialQuant=8;
	enc_param.u32IPInterval=avctx->gop_size;
	enc_param.bEnable4MV=avctx->enable_4mv;
#if 0 //def H263
	enc_param.bH263Quant=1;
	enc_param.bShortHeader=1;
#else
	enc_param.bH263Quant=1;
	enc_param.bShortHeader=0;
#endif
	enc_param.bResyncMarker=0;
	enc_param.u32MaxQuant=avctx->qmax;
	enc_param.u32MinQuant=avctx->qmin;    
	
    	enc_param.bROIEnable   = 0;     //0:disable 1:enable
	enc_param.u32ROIX      = 0;     // must be a multiple of 16 pixels
    	enc_param.u32ROIY      = 0;     // must be a multiple of 16 pixels
    		    	
	    		
    	enc_param.u32ROIWidth  = enc_param.u32FrameWidth;   // must be a multiple of 16 pixels
    	enc_param.u32ROIHeight = enc_param.u32FrameHeight;  // must be a multiple of 16 pixels
//  	enc_param.motion_dection_enable=(mval.alarm_picture_enable|mval.alarm_video_enable);
#else
	enc_param.u32BitRate = avctx->bit_rate;
	enc_param.u32FrameWidth = avctx->width;
	enc_param.u32FrameHeight = avctx->height;
	enc_param.fFrameRate = avctx->framerate / avctx->frame_rate_base;
    enc_param.u32InitialQuant = 8;
	enc_param.u32IPInterval = avctx->gop_size;
	enc_param.bShortHeader = 0;
	enc_param.bEnable4MV = 0;
	enc_param.bH263Quant = 1;
	enc_param.bResyncMarker = 0;
	enc_param.u32MaxQuant = avctx->qmax;
	enc_param.u32MinQuant = avctx->qmin;
    
	enc_param.bROIEnable   = 0;     //0:disable 1:enable
    enc_param.u32ROIX      = 0;     // must be a multiple of 16 pixels
	enc_param.u32ROIY      = 0;     // must be a multiple of 16 pixels
	enc_param.u32ROIWidth  = enc_param.u32FrameWidth;   // must be a multiple of 16 pixels
	enc_param.u32ROIHeight = enc_param.u32FrameHeight;  // must be a multiple of 16 pixels

#endif    
    if((mval.alarm_picture_enable|mval.alarm_video_enable)== 1)
        frm_count = 0;
    	
    RateControlInit(&ratec,enc_param.u32BitRate*1000, DELAY_FACTOR, RC_AVERAGE_PERIOD,
                    ARG_RC_BUFFER*1000, get_framerate(enc_param.fFrameRate),
                    enc_param.u32MaxQuant,enc_param.u32MinQuant,enc_param.u32InitialQuant);

    err = ioctl(fmpeg4_enc_fd,FMPEG4_IOCTL_ENCODE_INIT,&enc_param);
    if(err < 0)
    {
    	close(fmpeg4_enc_fd);
	    printf("Error to set FMPEG4_IOCTL_INIT\n");
	    return -1;
    }
    
    avctx->coded_frame = malloc(sizeof(AVFrame));
    memset(avctx->coded_frame, 0, sizeof(AVFrame));
    avctx->coded_frame->key_frame = 1;
    
/* set quant table */
    if(fmpeg4_get_intra_quant_tbls(cust_intra_qtbl)==0)
    {
        fprintf(stderr,"No Intra Quant Exist!\n");fflush(stderr);
        return 0;
    }
    if(fmpeg4_get_inter_quant_tbls(cust_inter_qtbl)==0)
    {
        fprintf(stderr,"No Inter Quant Exist!\n");fflush(stderr);
        return 0;
    }

	err=ioctl(fmpeg4_enc_fd,FMPEG4_IOCTL_SET_INTER_QUANT,cust_inter_qtbl);
	if(err<0)
	{
		printf("Error to set FMPEG4_IOCTL_SET_INTER_QUANT\n");
		return -1;
	}
	err=ioctl(fmpeg4_enc_fd,FMPEG4_IOCTL_SET_INTRA_QUANT,cust_intra_qtbl);
	if(err<0)
	{
		printf("Error to set FMPEG4_IOCTL_SET_INTRA_QUANT\n");
		return -1;
	}	

	return 0;
}



int enc_close(video_profile *avctx)
{

	if(fmpeg4_enc_fd)
		close(fmpeg4_enc_fd);
	fmpeg4_enc_fd = 0;
	free(avctx->coded_frame);
	return 0;
}



void fmpeg4_get_mb_info(MACROBLOCK_INFO *mbinfo)
{
	int err;
	
	err=ioctl(fmpeg4_enc_fd,FMPEG4_IOCTL_ENCODE_INFO,mbinfo);
	if(err<0)
	{
	    printf("Error to set FMPEG4_IOCTL_ENCODE_INFO\n");
	    return;
	}
}

void fmpeg4_get_mb_flag(int *flag)
{
	int err;
	
	err=ioctl(fmpeg4_enc_fd,FMPEG4_IOCTL_ENCODE_FLAG,flag);
	if(err<0)
	{
	    printf("Error to set FMPEG4_IOCTL_ENCODE_FLAG\n");
	    return;
	}
}


int xvid_encode(video_profile *avctx, unsigned char *frame, void * data)
{
    AVFrame             *pict=(AVFrame *)data;
    int                 err;
    Faraday_ENC_FRAME   enc_frame;

/*
#ifndef NEW_VERSION
    {
        int y_sz,uv_sz;
        y_sz = (cap_width * cap_height);
        uv_sz = (cap_width * cap_height)/4;
        if(pict->data[0] != 0)
        {

            memcpy(mmap_addr, pict->data[0], y_sz);
            memcpy(mmap_addr + y_sz, pict->data[1], uv_sz);
            memcpy(mmap_addr + y_sz+uv_sz, pict->data[2], uv_sz);
            enc_frame.pu8YFrameBaseAddr = mmap_addr;
            enc_frame.pu8UFrameBaseAddr = mmap_addr + y_sz;
            enc_frame.pu8VFrameBaseAddr = mmap_addr + y_sz + uv_sz;
           
        }
        else
        {
            enc_frame.pu8YFrameBaseAddr = 0;
            enc_frame.pu8UFrameBaseAddr = 0;
            enc_frame.pu8VFrameBaseAddr = 0;
        }
    }
#else
*/
    enc_frame.pu8YFrameBaseAddr = (unsigned char *)pict->data[0];   //input user continued virtual address (Y), Y=0 when NVOP
    enc_frame.pu8UFrameBaseAddr = (unsigned char *)pict->data[1];   //input user continued virtual address (U)
    enc_frame.pu8VFrameBaseAddr = (unsigned char *)pict->data[2];   //input user continued virtual address (V)

//#endif
    enc_frame.bitstream = frame;  //output User Virtual address
    if(avctx->quant == 0)
    	enc_frame.quant = ratec.rtn_quant;
    else	
    {
    	enc_frame.quant = avctx->quant;
  
    }
    enc_frame.intra = -1;

	err = ioctl(fmpeg4_enc_fd, FMPEG4_IOCTL_ENCODE_FRAME, &enc_frame);
	
 	if(enc_frame.length == 6)
 	{
 	int i;
 	printf("NVOP:");
 	for(i=0;i<enc_frame.length;i++)
	 	printf("%02x",frame[i]);
	 
	printf("\n");
	}
    if(err < 0)
    {
	    printf("Error to set FMPEG4_IOCTL_ENCODE_FRAME\n");
	    return -1;
    }

    	RateControlUpdate(&ratec, enc_frame.quant, enc_frame.length, enc_frame.intra);   

    if(((mval.alarm_picture_enable==1)||(mval.alarm_video_enable==1))&&(mval.enable==1)&&(pict->data[0]!=0))  
    {
        //motion dection enable
        int mb_width,mb_height,flag=0;
        MOTION_INFO     motion;

	    motion_info_set(&motion);
        mb_width=(avctx->width+15)/16;
        mb_height=(avctx->height+15)/16;

        if(mdinfo==0)
            mdinfo=malloc(sizeof(MACROBLOCK_INFO)*mb_width*mb_height);
            
        fmpeg4_get_mb_info(mdinfo);
	
        //do motion detection
        enc_frame.active0=0;
        enc_frame.active1=0;
        enc_frame.active2=0;

        fmpeg4_get_mb_flag(&flag);

	    if(flag)
	    {
       		motion_dection_1mv(mdinfo, &motion, &enc_frame, mb_width, mb_height);
	        motion_alarm_action(&enc_frame,avctx->width,avctx->height,pict->data[0],pict->data[1],pict->data[2]);
	    }
    }

	pict->key_frame = enc_frame.intra; //the return value in enc_frame.intra


    return enc_frame.length;
}
#define PUT_16(p,v) ((p)[0]=((v)>>8)&0xff,(p)[1]=(v)&0xff)
#define PUT_32(p,v) ((p)[0]=((v)>>24)&0xff,(p)[1]=((v)>>16)&0xff,(p)[2]=((v)>>8)&0xff,(p)[3]=(v)&0xff)
#define GET_16(p) (((p)[0]<<8)|(p)[1])
#define GET_32(p) (((p)[0]<<24)|((p)[1]<<16)|((p)[2]<<8)|(p)[3])

static int find_next_code( unsigned char *d, int len )
{
	int i;

	/* Start at 1 to ignore the code sitting at d[0] */
	for( i = 1; i < len - 2; ++i )
		if( d[i] == 0x00 && d[i+1] == 0x00 && d[i+2] == 0x01 )
			return i;
	return 0;
}


static unsigned int get_field( unsigned char *d, int bits, int *offset )
{
	unsigned int v = 0;
	int i;

	for( i = 0; i < bits; )
	{
		if( bits - i >= 8 && *offset % 8 == 0 )
		{
			v <<= 8;
			v |= d[*offset/8];
			i += 8;
			*offset += 8;
		} else
		{
			v <<= 1;
			v |= ( d[*offset/8] >> ( 7 - *offset % 8 ) ) & 1;
			++i;
			++(*offset);
		}
	}
	return v;
}

static void parse_video_object_layer( struct frame_info *out,
				unsigned char *d, int len )
{