state.c~

cam ui application for linux

#include <stdio.h>
#include <time.h>
#include <signal.h>
#include <sys/statvfs.h>
#include <asm/types.h>
#include <errno.h>
#include <unistd.h>
#include <string.h> 
#include <sys/ioctl.h>
#include <sys/time.h>
#include <mntent.h>
#include <stdlib.h>
#include <fcntl.h>
#include <termios.h>
#include <ctype.h>
#include <sys/utsname.h> 
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <pthread.h>
#include "error.h"
#include "memorycam.h"
#include "panel.h"
#include "state.h"
#include "utl.h"
#include "../common/nvram_linux.h"
/*#include "../module.qpixel/qldriver_app/ql202B/common/videodev2.h"	
#include "../module.qpixel/qldriver_app/ql202B/common/qlioctl.h"
#include "../module.qpixel/qldriver_app/ql202B/common/qltypes.h"
//#include "../module.qpixel/qldriver_app/ql202B/testapp3/qlstream.h"
//#include "../module.qpixel/qldriver_app/ql202B/testapp3/qt.h"
*/


//rober add motion 20071016   #include <sys/wait.h>
#define _STATE_
#define TEST_MD
#define __TESTMD_H__
#define ENCODE_INTERVAL 60
int month_temp=0;
int _ForkENCProcess (void);
int year_state=0;
int month_state=0;
int day_state=0;
int hour_state=0;
int min_state=0;
int sec_state=0;//rober
int Rec_Status=REC_NU;
int osd=0;
int MD;
//int   nKey = KEY_NO_KEY;
//int iStatus;
char Rate[3];
char TimeB[2];
char aCmdBuf[80];
char aFileType[5][5] = {{"PS"}, {"MP4"}, {"iPod"}, {"PSP"}, {"A800"}};
char aExtNmae[5][4] = {{"mpg"}, {"mp4"}, {"mp4"}, {"mp4"}, {"mp4"}};
int iStateNow, iStateNext;
pid_t ENCpid,FORK_osd,FORK_MD;
char aFuncStatusDisp[5][9] = {{" Disable"}, { " Enable"}};
char aSchduleDisp[5][9] = {{" Disable"}, { " Enable"},{"Str Time"},{"Rec Time"}};
char aFileTypeDisp[5][6] = {{" PS"}, {" MP4"}, {" iPod"}, {" PSP"}, {" A800"}};
char aBitrateDisp[5][9] = {{" 1.5Mbps"}, {" 1Mbps"}, {" 768kbps"}, {" 512kbps"}, {" 384kbps"}}; 
char aFramerateDisp[2][7] = {{" 30fps"}, {" 15fps"}};
char aImageDisp[2][9]={{"   Nomal"},{" Reverse"}};
char dateBuffer[]= {"date 010100002000.00"};
//////////////////SCH//////////////////////////
char SchBuffer[] = {"Day:01 Hour:00 Min:00"};
char Rec_Buffer[] = {"000 min"};
char *value_time;
int sch_status=SCH_STOP;
int default_sch_day=1;
int default_sch_hour=0;
int default_sch_min=0;
int default_rec_time=0;
int SC_Value=0;
char nvsetday[]={"systool set NV_SCH_DAY=1 "};
char nvsethour[]={"systool set NV_SCH_HOUR=0 "};
char nvsetmin[]={"systool set NV_SCH_MIN=0 "};
char nvsettime[]={"systool set NV_REC_TIME=0  "};
char nvbitrate[]={"systool set BITRATE_STATUS=0 "};
char nvframerate[]={"systool set FRAMERATE_STATUS=0 "};
////////////////Motion detection///////////////
//char	*QlDevEncName[] = { "/dev/video0",  "/dev/video1",  "/dev/video2",  "/dev/video3"  };
//unsigned long qldevoffset= 0;
unsigned long hEncDev1= 0;
int MD_Value=0;
extern int MD_Result;
#define MD_WIN_NUM 6
//volatile unsigned int bCtrlCReceived = FALSE;
extern BYTE abyResult[MD_WIN_NUM];
int MD_Detect_Count;
int MD_Status=M_DETEC_STOP;
extern struct 	_mcmode 	mcontrol;
/////////////FreeMb////////////////////////////
static struct statvfs StatVfs8;
static struct statvfs *pStatVfs8 = &StatVfs8;
static int statusVfs = -1;
//pthread_t pidMDThreadID;
long Err=0;
static unsigned long freeMb;
int iRecording=0;
int err=0;
//////////////////////////////////

int STATE_FindNextState (int iProcessKey)
{
    switch (iStateNow)
    {
        case STATE_STANDBY:
            switch (iProcessKey)
            {
                case KEY_KEY1:
                    if (iErrCode)
                        iStateNext = STATE_STANDBY;
                    else
                        iStateNext = STATE_SET_VIOSD; 
                    break;
                case KEY_KEY2:
                    if (iErrCode)
                        iStateNext = STATE_STANDBY;
                    else
                        		iStateNext = STATE_REC;
                    break;
                case KEY_KEY3:
                    if (iErrCode)
                        iStateNext = STATE_STANDBY;
                    else
                        iStateNext = STATE_NO_CHANGE;
                    break;
                default:
                    iStateNext = STATE_NO_CHANGE;
                    break;
            }
            break;

        case STATE_REC:
            if (iErrCode)
            {
                iStateNext = STATE_STANDBY;
                break;
            }
            switch (iProcessKey)
            {
                case KEY_KEY2:
                    iStateNext = STATE_STANDBY;
                    break;
                default:
                    iStateNext = STATE_NO_CHANGE;
                    break;
            }
            break;

        case STATE_SET_VIOSD:
            switch (iProcessKey)
            {
                case KEY_KEY1:
                    iStateNext = STATE_SET_MD; 
                    break;
                case KEY_KEY2:
                    iStateNext = STATE_CHG_VIOSD; // STATE_CHG_VIOSD;
                    break;
                case KEY_KEY3:
                    iStateNext = STATE_STANDBY;
                    break;
                default:
                    iStateNext = STATE_NO_CHANGE;
                    break;
            }
            break;

        case STATE_CHG_VIOSD:
            switch (iProcessKey)
            {
                default:
                    iStateNext = STATE_SET_VIOSD;
                    break;
            }
            break;

        case STATE_SET_MD:
            switch (iProcessKey)
            {
                case KEY_KEY1:
                    iStateNext = STATE_SET_FILE_FMT; 
                    break;
                case KEY_KEY2:
                    iStateNext =  STATE_CHG_MD;
                    break;
                case KEY_KEY3:
                    iStateNext = STATE_STANDBY;
                    break;
                default:
                    iStateNext = STATE_NO_CHANGE;
                    break;
            }
            break;

        case STATE_CHG_MD:
            switch (iProcessKey)
            {
                default:
                    iStateNext = STATE_SET_MD;
                    break;
            }
            break;

        case STATE_SET_FILE_FMT:
            switch (iProcessKey)
            {
                case KEY_KEY1:
                    iStateNext = STATE_SET_BITRATE; 
                    break;
                case KEY_KEY2:
                    iStateNext = STATE_NO_CHANGE; // STATE_CHG_FILE_FMT;
                    break;
                case KEY_KEY3:
                    iStateNext = STATE_STANDBY;
                    break;
                default:
                    iStateNext = STATE_NO_CHANGE;
                    break;
            }
            break;

        case STATE_CHG_FILE_FMT:
            switch (iProcessKey)
            {
                default:
                    iStateNext = STATE_SET_FILE_FMT;
                    break;
            }
            break;

        case STATE_SET_BITRATE:
            switch (iProcessKey)
            {
                case KEY_KEY1:
                    iStateNext = STATE_SET_FRAMERATE; 
                    break;
                case KEY_KEY2:
                    iStateNext = STATE_CHG_BITRATE;
                    break;
                case KEY_KEY3:
                    iStateNext = STATE_STANDBY;
                    break;
                default:
                    iStateNext = STATE_NO_CHANGE;
                    break;
            }
            break;

        case STATE_CHG_BITRATE:
            switch (iProcessKey)
            {
                default:
                    iStateNext = STATE_SET_BITRATE;
                    break;
            }
            break;

        case STATE_SET_FRAMERATE:
            switch (iProcessKey)
            {
                case KEY_KEY1:
                    iStateNext = STATE_SET_SCH_REC;
                    break;
                case KEY_KEY2:
                    iStateNext = STATE_CHG_FRAMERATE;
                    break;
                case KEY_KEY3:
                    iStateNext = STATE_STANDBY;
                    break;
                default:
                    iStateNext = STATE_NO_CHANGE;
                    break;
            }
            break;

        case STATE_CHG_FRAMERATE:
            switch (iProcessKey)
            {
                default:
                    iStateNext = STATE_SET_FRAMERATE;
                    break;
            }
            break;

        case STATE_SET_SCH_REC:
            switch (iProcessKey)
            {
                case KEY_KEY1:
                    if (iSchRec == SCHREC_ENABLE)
                        iStateNext = STATE_SET_SCH_REC_START;
                    else
                        iStateNext = STATE_SET_DATE;
                    break;
                case KEY_KEY2:
                    iStateNext = STATE_CHG_SCH_REC; // STATE_CHG_SCH_REC;
                    break;
                case KEY_KEY3:
                    iStateNext = STATE_STANDBY;
                    break;
                default:
                    iStateNext = STATE_NO_CHANGE;
                    break;
            }
            break;
         
						
        case STATE_CHG_SCH_REC:
            switch (iProcessKey)
            {
                default:
                    iStateNext = STATE_SET_SCH_REC;
                    break;
            }
            break;

        case STATE_SET_SCH_REC_START:
            switch (iProcessKey)
            {
                case KEY_KEY1:
                    iStateNext = STATE_SET_SCH_REC_TIME; 
                    break;
                case KEY_KEY2:
                    iStateNext = STATE_SET_SCH_REC_DAY;   // Under defining
                    break;
                case KEY_KEY3:
                    iStateNext = STATE_STANDBY;
                    break;
                default:
                    iStateNext = STATE_NO_CHANGE;
                    break;
            }
            break;
        
        case STATE_SET_SCH_REC_DAY:                      //Rober sch day
        		switch (iProcessKey)
            {
                case KEY_KEY1:
                    iStateNext = STATE_SET_SCH_REC_HOUR; 
                    break;
                case KEY_KEY2:
                    iStateNext = STATE_CHG_SCH_REC_DAY;   // Under defining
                    break;
                case KEY_KEY3:
                    iStateNext = STATE_NO_CHANGE;
                    break;
                default:
                    iStateNext = STATE_NO_CHANGE;
                    break;
            }
            break;
            
        case STATE_CHG_SCH_REC_DAY:
            switch (iProcessKey)
            {
                default:
                    iStateNext = STATE_SET_SCH_REC_DAY;
                    break;
            }
            break;

				case STATE_SET_SCH_REC_HOUR:                      //Rober sch hour
        		switch (iProcessKey)
            {
                case KEY_KEY1:
                    iStateNext = STATE_SET_SCH_REC_MIN; 
                    break;
                case KEY_KEY2:
                    iStateNext = STATE_CHG_SCH_REC_HOUR;   // Under defining
                    break;
                case KEY_KEY3:
                    iStateNext = STATE_NO_CHANGE;
                    break;
                default:
                    iStateNext = STATE_NO_CHANGE;
                    break;
            }
            break;
            
        case STATE_CHG_SCH_REC_HOUR:
            switch (iProcessKey)
            {
                default:
                    iStateNext = STATE_SET_SCH_REC_HOUR;
                    break;
            }
            break;
            
        case STATE_SET_SCH_REC_MIN:                      //Rober sch min
        		switch (iProcessKey)
            {
                case KEY_KEY1:
                    iStateNext = STATE_SET_SCH_REC_TIME; 
                    break;
                case KEY_KEY2:
                    iStateNext = STATE_CHG_SCH_REC_MIN;   // Under defining
                    break;
                case KEY_KEY3:
                    iStateNext = STATE_NO_CHANGE;
                    break;
                default:
                    iStateNext = STATE_NO_CHANGE;
                    break;
            }
            break;
            
        case STATE_CHG_SCH_REC_MIN:
            switch (iProcessKey)
            {
                default:
                    iStateNext = STATE_SET_SCH_REC_MIN;
                    break;
            }
            break;

        case STATE_SET_SCH_REC_TIME:
            switch (iProcessKey)
            {
                case KEY_KEY1:
                    iStateNext = STATE_SET_DATE; 
                    break;
                case KEY_KEY2:
                    iStateNext = STATE_CHG_SCH_REC_TIME;   // Under defining
                    break;
                case KEY_KEY3:
                    iStateNext = STATE_NO_CHANGE;
                    break;
                default:
                    iStateNext = STATE_NO_CHANGE;
                    break;
            }
            break;
            
        case STATE_CHG_SCH_REC_TIME:
            switch (iProcessKey)
            {
                default:
                    iStateNext = STATE_SET_SCH_REC_TIME;
                    break;
            }