int SendForceIFrameMsg(unsigned char nValue)
{
MSG_BUF msgbuf;
unsigned char* ptr;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
msgbuf.cmd = MSG_CMD_SET_IFRAME;
ptr = (unsigned char*)&msgbuf.mem_info;
*ptr = nValue;
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
return msgbuf.ret;
}
/**
* @brief day / night mode setting for UI
*
*
* @param nDayNight 0 : night mode 1: day mode
*
* @return 0 is ok and -1 is error
*
*
*/
int SetDayNight(unsigned char nDayNight)
{
MSG_BUF msgbuf;
unsigned char* ptr;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
msgbuf.cmd = MSG_CMD_SET_DAY_NIGHT;
ptr = (unsigned char*)&msgbuf.mem_info;
*ptr = nDayNight;
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
return msgbuf.ret;
}
/**
* @brief Motion Enable mode setting for UI
*
*
* @param enableVal 0: Enable 1:Disable
*
* @return 0 is ok and -1 is error
*
*
*/
int ApproSetMotion(ApproMotionPrm* pMotionPrm)
{
MSG_BUF msgbuf;
void* ptr;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
msgbuf.cmd = MSG_CMD_SET_MOTION;
ptr = (void*)&msgbuf.mem_info;
memcpy(ptr, pMotionPrm, sizeof(ApproMotionPrm));
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
return msgbuf.ret;
}
int SetDateTimeFormat(DateTimePrm* datetimeParam)
{
MSG_BUF msgbuf;
unsigned char* ptr;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
msgbuf.cmd = MSG_CMD_SET_DATETIMEPRM;
ptr = (unsigned char*)&msgbuf.mem_info;
memcpy(ptr, datetimeParam, sizeof(DateTimePrm));
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
return msgbuf.ret;
}
/**
* @brief Message driver for waiting newframe (Do not use now)
*
*
* @param fmt stucture pointer of frame information, defined at Msg_def.h
*
* @return 0 is ok and -1 is error
*
*
*/
FrameInfo_t WaitNewFrame(FrameFormat_t fmt)
{
MSG_BUF msgbuf;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
msgbuf.cmd = MSG_CMD_GET_NEW_FRAME;
msgbuf.frame_info.format = fmt;
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
if(msgbuf.ret != 0)
msgbuf.frame_info.serial_no = -1;
return msgbuf.frame_info;
}
int SetOSDWindow(int nValue)
{
MSG_BUF msgbuf;
int* ptr;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
msgbuf.cmd = MSG_CMD_SET_OSDWINDOW;
ptr = (int*)&msgbuf.mem_info;
*ptr = nValue;
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
return msgbuf.ret;
}
int SetRTSPStreamingON(int nExtFunc)
{
char opt[32] = "./wis-streamer";
int ret = 0;
if(((int)(~RTSP_FUNC_MASK)) & nExtFunc){
fprintf(stderr,"ERROR: Invalid parameter to Control RTSP!!!\n");
return -1;
}
SemWait(hndlRTSP_Sem);
if(gRTSP_Mode & RTSP_RUN){
if((gRTSP_Mode & RTSP_FUNC_MASK) == nExtFunc){
/* run in the same mode */
SemRelease(hndlRTSP_Sem);
return 0;
}else {
/* run in other mode */
ret = TurnOffRTSPStreaming();
}
}
if(RTSP_MUTE & nExtFunc)
strcat(opt, " -s");
if(RTSP_AAC & nExtFunc)
strcat(opt, " -a");
if(RTSP_SVC & nExtFunc)
strcat(opt, " -v");
if(RTSP_MULTICAST & nExtFunc)
strcat(opt, " -m");
strcat(opt, "&\n");
//printf(opt);
if(ret == 0)
ret = system(opt);
if(ret == 0){
gRTSP_Mode = RTSP_RUN | nExtFunc;
sleep(2);
}
R_DB("gRTSP_Mode = %d\n", gRTSP_Mode);
SemRelease(hndlRTSP_Sem);
return ret;
}
int ResumePlaybackChMsg(unsigned char* nValue)//add by sxh
{
MSG_BUF msgbuf;
unsigned char* ptr;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
msgbuf.cmd = MSG_CMD_RESUME_PLAYBACKCH;
ptr = (unsigned char*)&msgbuf.mem_info;
memcpy(ptr, nValue, strlen(nValue));
printf("ResumePlaybackChMsg:ptr=%s\n",ptr);
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
return msgbuf.ret;
}
int SendFaceDetectMsg(FaceDetectParam* faceParam)
{
MSG_BUF msgbuf;
void* ptr;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
msgbuf.cmd = MSG_CMD_SET_FDETECT;
ptr = (void*)&msgbuf.mem_info;
memcpy(ptr, faceParam, sizeof(FaceDetectParam));
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
return msgbuf.ret;
}
void PrintDriver()
{
int i, code;
char *p;
msg_t temp_msg;
printing_semaphore = SemGet(0); //request semaphore printing_semaphore, limit 0.
// reset printer (check printer power, cable, and paper), it will jitter
outportb(LPT1_BASE+LPT_CONTROL, PC_SLCTIN); // CONTROL reg, SeLeCT INterrupt
code = inportb(LPT1_BASE+LPT_STATUS); // read STATUS
for(i = 0; i < 50; i++) //loop 50 times of IO_DELAY();
{
IO_DELAY();
}
outportb(LPT1_BASE+LPT_CONTROL, PC_INIT|PC_SLCTIN|PC_IRQEN); // IRQ ENable
Sleep(1); //Sleep for a second, needs time resetting
while(1)//forever loop:
{
temp_msg.recipient = running_pid;
MsgRcv(&temp_msg);//receive a message, get if msg to print *******
p = temp_msg.data;
cons_printf("PrintDriver (PID %d) now prints...\n", GetPid()); //a notification msg (match how demo runs)
//set p to point to start of character string in message
while (*p != '\0') //"what p points to" is not null/empty/(char)0,
{
outportb(LPT1_BASE+LPT_DATA, *p); // write char to DATA reg
code = inportb(LPT1_BASE+LPT_CONTROL); // read CONTROL reg
outportb(LPT1_BASE+LPT_CONTROL, code|PC_STROBE); // write CONTROL, STROBE added
for(i = 0; i < 50; i++) //do 50 times of IO_DELAY
{
IO_DELAY();
}
outportb(LPT1_BASE+LPT_CONTROL, code); // send back original CONTROL
SemWait(printing_semaphore);//semaphore-wait on the printing semaphore
p++; //move p to next character to print
}
}
}
/**
* @brief Message driver for getting MPEG4 VOL data
*
*
* @param pVolBuf ouput buffer for getting MPEG4 VOL data
*
* @param fmt_type frame type ID : FMT_MJPEG, FMT_MPEG4 , FMT_MPEG4_EXT, FMT_AUDIO, defined at Msg_def.h
*
* @return 0 is ok and -1 is error
*
*
*/
int GetVolInfo(FrameInfo_t *pFrame, int fmt_type)
{
MSG_BUF msgbuf;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
msgbuf.cmd = MSG_CMD_GET_VOL;
msgbuf.frame_info.format = fmt_type;
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
pFrame->offset = msgbuf.frame_info.offset;
pFrame->size = msgbuf.frame_info.size;
return msgbuf.frame_info.size;
}
/**
* @brief Message driver for getting current frame information
*
*
* @param fmt stucture of frame information, defined at Msg_def.h
*
*
*
*/
FrameInfo_t GetCurrentFrame(FrameFormat_t fmt)
{
MSG_BUF msgbuf;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
msgbuf.cmd = MSG_CMD_GET_CUR_FRAME;
msgbuf.frame_info.format = fmt;
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
printf("************** msgbuf.ret: %d\n",msgbuf.ret);//add by sxh
if(msgbuf.ret != 0)
msgbuf.frame_info.serial_no = -1;
return msgbuf.frame_info;
}
int SetAvOsdLogoEnable(int enable)
{
MSG_BUF msgbuf;
int* ptr;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
msgbuf.cmd = MSG_CMD_SET_OSDLOGO_EN;
ptr = (int*)&msgbuf.mem_info;
*ptr = enable;
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
return msgbuf.ret;
}
/**
* @brief Bitrate setting for UI
*
*
* @param stream 0: stream1 720P \n
* 1: stream2 SIF \n
*
* @param nValue 64~8000
*
* @return 0 is ok and -1 is error
*
*
*/
int SetEncBitrate(unsigned char stream, int nValue)
{
MSG_BUF msgbuf;
int* ptr;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
if (stream == 0)
msgbuf.cmd = MSG_CMD_SET_BITRATE1;
else
msgbuf.cmd = MSG_CMD_SET_BITRATE2;
ptr = (int*)&msgbuf.mem_info;
*ptr = nValue;
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
return msgbuf.ret;
}
/**
* @brief PTZ setting for UI
*
*
* @param nValue 0: PTZ_ZOOM_IN \n
* 1: PTZ_ZOOM_OUT \n
* 2: PTZ_PAN_UP \n
* 3: PTZ_PAN_DOWN \n
* 4: PTZ_PAN_LEFT \n
* 5: PTZ_PAN_RIGHT \n
* 6: PTZ_INIT_4X\n
* 7: PTZ_ZOOM_EMPTY \n
* 8: PTZ_ZOOM_RESET
*
*@note This function only work at sensor output is VGA
* @return 0 is ok and -1 is error
*
*
*/
int SetPtz(int nValue)
{
MSG_BUF msgbuf;
unsigned char* ptr;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
msgbuf.cmd = MSG_CMD_PTZ;
ptr = (unsigned char*)&msgbuf.mem_info;
*ptr = nValue;
SemWait(hndlApproDrvSem);
printf("Setptz:nValue:%s!\n",nValue);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
printf("Setptz Done:nValue:%s!\n",nValue);
printf("SetptzDone!\n");
SemRelease(hndlApproDrvSem);
return msgbuf.ret;
}
int GetPbRecDayDataMsg(unsigned char* nValue)//add by sxh
{
MSG_BUF msgbuf;
unsigned char* ptr;
printf("GetPbRecHourDataMsg:nValue:%s!\n",nValue);
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
msgbuf.cmd = MSG_CMD_GET_PBRECDAY;
ptr = (unsigned char*)&msgbuf.mem_info;
memcpy(ptr, nValue, 32);
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
ptr = (unsigned char*)&msgbuf.mem_info;
memcpy(nValue, ptr, 32);
printf("GetPbRecHourDataMsg Done:nValue:%s!\n",nValue);
SemRelease(hndlApproDrvSem);
return msgbuf.ret;
}
int SetClipSnapName(char* strText, int nLength)
{
MSG_BUF msgbuf;
int* ptr;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
msgbuf.cmd = MSG_CMD_SET_CLICKNAME;
ptr = (int*)&msgbuf.mem_info;
*ptr = nLength;
memcpy(++ptr, strText, nLength);
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
return msgbuf.ret;
}
int LoopCommand2(ThreadData* aThreadData)
{
int j = 0,retval=0;
for(int i=0; i < 1000; i += 100)
{
j++;
if(j == 255)
{
j = 0;
#ifdef WINDOWS
printf("%dLooping Id: %d Cmd1 %d Cmd2 %d\n",i,aData->iSelf,Command1, Command2);
#else
{
//MSG(_L("%dLooping Id: %d Cmd1 %d Cmd2 %d\n"),i,aData->iSelf,Command1, Command2);
}
#endif
}
retval = SemPost(aThreadData);
retval = SemWait(aThreadData);
}
return retval;
}
/**
* @brief Set alarm duration
* @return 0 on success.
*/
int Set_AlarmDuration(int durationTime)
{
int alarm_count = 0;
if(durationTime == 0)
{
alarm_count = 10;
}else if(durationTime == 1){
alarm_count = 30;
}else if(durationTime == 2){
alarm_count = 60;
}else if(durationTime == 3){
alarm_count = 300;
}else if(durationTime == 4){
alarm_count = 600;
}else{
alarm_count = -1;
}
SemWait(hGIOSem);
alarmDurationTime = alarm_count;
DBG("Set_AlarmDuration = %d\n",alarmDurationTime);
SemRelease(hGIOSem);
return 0;
}
int SetCodecAdvPrmMsg(int id, CodecAdvPrm* codecAdvPrm)
{
MSG_BUF msgbuf;
unsigned char* ptr;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
if(id==0)
msgbuf.cmd = MSG_CMD_SET_ADVCODECPRM1;
else if(id==1)
msgbuf.cmd = MSG_CMD_SET_ADVCODECPRM2;
else if(id==2)
msgbuf.cmd = MSG_CMD_SET_ADVCODECPRM3;
ptr = (unsigned char*)&msgbuf.mem_info;
memcpy(ptr, codecAdvPrm, sizeof(CodecAdvPrm));
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
return msgbuf.ret;
}
int main()
{
PutString("\n-----------------------------------------\n");
PutString("Lancement du test testBcpThreads : \n");
PutString("Lance plusieurs threads affichant un nombre different avec semaphore pour l'acces.\n");
PutString("-----------------------------------------\n");
int i;
int nb[NB_THREADS];
SemInit(&s, 1);
for(i = 0 ; i < NB_THREADS ; i++)
{
nb[i] = i;
if(UserThreadCreate(f, &nb[i]) == -1)
{
SemWait(&s);
PutString("Echec de creation du thread : ");
PutInt(i);
PutString("\n");
SemPost(&s);
}
}
PutString("thread main se termine\n");
return 0;
}
/**
* @brief Set alarm audio count
* @param alarmDuration [i] alarm duration
* @return 0 on success.
*/
int setAudioCount(int alarmDuration)
{
int alarm_count;
if(alarmDuration == 0){
alarm_count = 2;
}else if(alarmDuration == 1){
alarm_count = 6;
}else if(alarmDuration == 2){
alarm_count = 12;
}else if(alarmDuration == 3){
alarm_count = 60;
}else if(alarmDuration == 4){
alarm_count = 120;
}else if(alarmDuration == -1){
alarm_count = 0;
}else{
alarm_count = 1999;
}
SemWait(audioSem);
audio_count = alarm_count;
DBG("setAudioCount=%d\n",audio_count);
SemRelease(audioSem);
return 0;
}
int SetVNFStatus(unsigned char stream, unsigned char nValue)
{
MSG_BUF msgbuf;
unsigned int* ptr;
memset(&msgbuf,0,sizeof(msgbuf));
msgbuf.Des = MSG_TYPE_MSG1;
msgbuf.Src = PROC_MSG_ID;
if (stream == 0)
msgbuf.cmd = MSG_CMD_SET_VNFSTATUS1;
else if (stream == 1)
msgbuf.cmd = MSG_CMD_SET_VNFSTATUS2;
else if (stream == 2)
msgbuf.cmd = MSG_CMD_SET_VNFSTATUS3;
ptr = (unsigned int*)&msgbuf.mem_info;
*ptr = nValue;
SemWait(hndlApproDrvSem);
msgsnd( qid,&msgbuf,sizeof(msgbuf)-sizeof(long),0);/*send msg1*/
msgrcv( qid, &msgbuf,sizeof(msgbuf)-sizeof(long), PROC_MSG_ID, 0);
SemRelease(hndlApproDrvSem);
return msgbuf.ret;
}
void StdoutChar(int term_num, char ch)
{
EnCharQ(ch, &terminals[term_num].out_q);
if(terminals[term_num].missed_intr) IRQ34ISROutChar(term_num);
SemWait(terminals[term_num].out_sid);
}
//sem_getvalue on a semaphore posted n times
TInt CTestSemgetvalue::TestSem316( )
{
int retval = 0;
int errsum=0, err = 0;
ThreadData lThreadData;
sem_t lSignalSemaphore;
sem_t lSuspendSemaphore;
sem_t lTestSemaphore;
pthread_mutex_t lTestMutex;
pthread_cond_t lTestCondVar;
pthread_condattr_t lCondAttr;
pthread_mutexattr_t lTestMutexAttr;
pthread_mutexattr_t defaultattr;
pthread_mutexattr_t errorcheckattr;
pthread_mutexattr_t recursiveattr;
pthread_mutexattr_init(&defaultattr);
pthread_mutexattr_init(&errorcheckattr);
pthread_mutexattr_init(&recursiveattr);
pthread_mutexattr_settype(&errorcheckattr,PTHREAD_MUTEX_ERRORCHECK);
pthread_mutexattr_settype(&recursiveattr,PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_t l_staticmutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t l_errorcheckmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
pthread_mutex_t l_recursivemutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
pthread_cond_t l_staticcondvar = PTHREAD_COND_INITIALIZER;
CommonData lCommonData;
lCommonData.iStaticMutex = &l_staticmutex;
lCommonData.iErrorCheckMutex = &l_errorcheckmutex;
lCommonData.iRecursiveMutex = &l_recursivemutex;
lCommonData.iStaticCondVar = &l_staticcondvar;
retval = sem_init(&lSignalSemaphore,0,0);
if(retval != 0)
{
return retval;
}
retval = sem_init(&lSuspendSemaphore,0,0);
if(retval != 0)
{
return retval;
}
lThreadData.iSignalSemaphore = &lSignalSemaphore;
lThreadData.iSuspendSemaphore = &lSuspendSemaphore;
lThreadData.iTestSemaphore = &lTestSemaphore;
lThreadData.iTestMutex = &lTestMutex;
lThreadData.iTestMutexAttr = &lTestMutexAttr;
lThreadData.iTestCondVar = &lTestCondVar;
lThreadData.iDefaultAttr = &defaultattr;
lThreadData.iErrorcheckAttr = &errorcheckattr;
lThreadData.iRecursiveAttr = &recursiveattr;
lThreadData.iCondAttr = &lCondAttr;
for (int loop = 0; loop < EThreadMain; loop++)
{
g_spinFlag[loop] = true;
}
lThreadData.iSuspending = false;
lThreadData.iSpinCounter = 0;
lThreadData.iCurrentCommand = -1;
lThreadData.iSelf = EThreadMain;
lThreadData.iValue = 0;
lThreadData.iRetValue = 0;
lThreadData.ierrno = 0;
lThreadData.iExpectederrno = 0;
lThreadData.iTimes = 0;
lThreadData.iStopped = false;
lThreadData.iCommonData = &lCommonData;
retval = SemInit(&lThreadData);
retval = SemPost(&lThreadData);
retval = SemPost(&lThreadData);
retval = SemPost(&lThreadData);
retval = SemPost(&lThreadData);
retval = SemWait(&lThreadData);
retval = SemWait(&lThreadData);
retval = SemGetValue(&lThreadData);
retval = CheckValue(&lThreadData,2);
retval = SemDestroy(&lThreadData);
StopThread(&lThreadData);
err = pthread_cond_destroy(&l_staticcondvar);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutex_destroy(&l_recursivemutex);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutex_destroy(&l_errorcheckmutex);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutex_destroy(&l_staticmutex);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutexattr_destroy(&recursiveattr);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutexattr_destroy(&errorcheckattr);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutexattr_destroy(&defaultattr);
if(err != EINVAL)
{
errsum += err;
}
err = sem_destroy(&lSignalSemaphore);
if(err != EINVAL)
{
errsum += err;
}
err = sem_destroy(&lSuspendSemaphore);
if(err != EINVAL)
{
errsum += err;
}
return retval+errsum;
}
/**
* @brief Alarm processing thread.
*/
void *ProcAlarmThread(void *arg)
{
int iCurTime;
void *status = PROC_SUCESS;
time_t tCurrentTime;
struct tm *tmnow;
AlarmParam_t* pEvironment = (AlarmParam_t*)arg;
unsigned char enableIn,enableOut=0,trigger;
LogEntry_t tLog;
SysInfo *pSysInfo = pAlarmSysInfo;
DBG("QID: %d\n", pEvironment ->msg_id);
DBG("From: %d\n", pEvironment ->msg_buf.src);
DBG("pSysInfo: %p\n", pSysInfo);
DBG("Index: %d\n", pEvironment ->msg_buf.index);
if((iCurTime = time(&tCurrentTime)) == -1){
ERR("Fail on get current time\n");
status =PROC_FAIL;
goto ALARM_EXIT;
}
tmnow = localtime(&tCurrentTime);
memcpy(&tLog.time, tmnow, sizeof(struct tm));
switch(pEvironment->msg_buf.event){
case ALARM_EVENT_AUDIO_TRIG:
{
int alarmDuration;
DBG("ALARM_EVENT_AUDIO_TRIG \n");
if((pSysInfo->audio_config.alarmON == 0)||
(pSysInfo->lan_config.alarmstatus&FLG_UI_AUDIO)){
break;
}
AddSchedule(AUDIO_SCHEDULE, tmnow, pSysInfo);
enableOut = (pSysInfo->lan_config.nExtAlarm&pSysInfo->lan_config.giooutenable);
trigger=pSysInfo->lan_config.gioouttype;
alarmDuration=pSysInfo->lan_config.nAlarmDuration;
if(enableOut==1){
dm355_gio_write(GIO_ALARMOUT,trigger);
Set_AlarmDuration(alarmDuration);
}
sprintf(tLog.event, "Audio Alarm");
fSetSysLog(&tLog);
int count=0;
count=getAudioCount();
if ( count > 0){
setAudioCount(alarmDuration);
break;
}
else
setAudioCount(alarmDuration);
AlarmAudio_Play(pEvironment->audMsg_id);
break;
}
case ALARM_EVENT_MOTION_DETECT:
{
int alarmDuration;
DBG("ALARM_EVENT_MOTION_DETECT \n");
if((pSysInfo->motion_config.motionenable==0)||
(pSysInfo->lan_config.alarmstatus&FLG_UI_MOTION)){
break;
}
SetJpegStartSerial(pEvironment->msg_buf.serial);
AddSchedule(MOTION_SCHEDULE, tmnow, pSysInfo);
enableOut = (pSysInfo->lan_config.nExtAlarm&pSysInfo->lan_config.giooutenable);
trigger=pSysInfo->lan_config.gioouttype;
alarmDuration=pSysInfo->lan_config.nAlarmDuration;
if(enableOut==1){
dm355_gio_write(GIO_ALARMOUT,trigger);
Set_AlarmDuration(alarmDuration);
}
sprintf(tLog.event, "Motion Alarm");
fSetSysLog(&tLog);
int count=0;
count=getAudioCount();
if ( count > 0){
setAudioCount(alarmDuration);
break;
}
else
setAudioCount(alarmDuration);
AlarmAudio_Play(pEvironment->audMsg_id);
break;
}
case ALARM_EVENT_ALARMRESET_TRIG:
{
DBG("ALARM_EVENT_ALARMRESET_TRIG \n");
ResetSchedule();
Set_AlarmDuration(0);
setAudioCount(-1);
break;
}
case ALARM_EVENT_ALARMIN_TRIG:
{
int alarmDuration;
DBG("ALARM_EVENT_ALARMIN_TRIG \n");
enableIn=(pSysInfo->lan_config.nExtAlarm&pSysInfo->lan_config.gioinenable);
alarmDuration=pSysInfo->lan_config.nAlarmDuration;
/** check if turn gio alarm on */
if((enableIn==0)||
(pSysInfo->lan_config.alarmstatus&FLG_UI_EXT)){
break;
}
AddSchedule(EXT_SCHEDULE, tmnow, pSysInfo);
enableOut = (pSysInfo->lan_config.nExtAlarm&pSysInfo->lan_config.giooutenable);
trigger=pSysInfo->lan_config.gioouttype;
if(enableOut==1){
dm355_gio_write(GIO_ALARMOUT,trigger);
Set_AlarmDuration(alarmDuration);
}
sprintf(tLog.event, "External Alarm");
fSetSysLog(&tLog);
int count=0;
count=getAudioCount();
if ( count > 0){
setAudioCount(alarmDuration);
break;
}
else
setAudioCount(alarmDuration);
AlarmAudio_Play(pEvironment->audMsg_id);
break;
}
case ALARM_EVENT_ALARMETH_TRIG:
{
int alarmDuration;
DBG("ALARM_EVENT_ALARMETH_TRIG \n");
alarmDuration=pSysInfo->lan_config.nAlarmDuration;
/** check if turn Ethernet alarm on */
if((pSysInfo->lan_config.lostalarm == 0)||
(pSysInfo->lan_config.alarmstatus&FLG_UI_ETH)){
break;
}
AddSchedule(ETH_SCHEDULE, tmnow, pSysInfo);
enableOut = (pSysInfo->lan_config.nExtAlarm&pSysInfo->lan_config.giooutenable);
trigger=pSysInfo->lan_config.gioouttype;
if(enableOut==1){
dm355_gio_write(GIO_ALARMOUT,trigger);
Set_AlarmDuration(alarmDuration);
}
sprintf(tLog.event, "Ethernet Alarm");
fSetSysLog(&tLog);
int count=0;
count=getAudioCount();
if ( count > 0){
setAudioCount(alarmDuration);
break;
}
else
setAudioCount(alarmDuration);
AlarmAudio_Play(pEvironment->audMsg_id);
break;
}
case ALARM_EVENT_SCHEDULE:
{
int nflag, bIsAviRun;
int isFTPAVI,isSDAVI;
int supportJPG,supportH264,supportH264cif,supportMpeg4,supportMpeg4cif,supportAVI;
DBG("ALARM_EVENT_SCHEDULE \n");
isFTPAVI=pSysInfo->ftp_config.ftpfileformat;
isSDAVI=pSysInfo->sdcard_config.sdfileformat;
supportJPG = pSysInfo->lan_config.Supportstream1;
supportMpeg4 = pSysInfo->lan_config.Supportstream2;
supportMpeg4cif = pSysInfo->lan_config.Supportstream3;
supportH264 = pSysInfo->lan_config.Supportstream5;
supportH264cif = pSysInfo->lan_config.Supportstream6;
supportAVI = supportH264|supportH264cif|supportMpeg4|supportMpeg4cif;
bIsAviRun = 0;
sprintf(tLog.event, "Schedule Record");
nflag =0;
if(pSysInfo->sdcard_config.sdinsert<=1){
if(supportAVI&&pSysInfo->sdcard_config.sdrenable&&isSDAVI==0&&
!gbSD_WriteProtect){
nflag |= AVI_TO_SD;
bIsAviRun = 1;
}
if(supportAVI&&pSysInfo->ftp_config.rftpenable&&isFTPAVI==0){
nflag |= AVI_TO_FTP;
bIsAviRun = 1;
}
if(bIsAviRun){
AviRun(0, nflag);
SemWait(pEvironment->hAlarmSem);
gSchAviRun = 1;
SemRelease(pEvironment->hAlarmSem);
}
} else {
/* AVI no stop case */
if(supportAVI&&pSysInfo->sdcard_config.sdrenable&&isSDAVI==0&&
!gbSD_WriteProtect){
AviRun(1, AVI_TO_SD);
SemWait(pEvironment->hAlarmSem);
gSchAviRun = 1;
SemRelease(pEvironment->hAlarmSem);
}
}
nflag =0;
if(isSDAVI==1&&pSysInfo->sdcard_config.sdrenable &&
!gbSD_WriteProtect)
nflag |= JPG_TO_SD;
/* Megapixel JPEG mode */
if(!supportAVI&&pSysInfo->sdcard_config.sdrenable&&!gbSD_WriteProtect)
nflag |= JPG_TO_SD;
if(pSysInfo->sdcard_config.sdinsert<=1){
if(isFTPAVI==1 &&pSysInfo->ftp_config.rftpenable)
nflag |= JPG_TO_FTP;
/* Megapixel JPEG mode*/
if(!supportAVI&&pSysInfo->ftp_config.rftpenable)
nflag |= JPG_TO_FTP;
if(nflag){
JpgRun(nflag, 0 );
SemWait(pEvironment->hAlarmSem);
gSchJpgRun = 1;
SemRelease(pEvironment->hAlarmSem);
}
}
else{
if(supportJPG&&pSysInfo->ftp_config.rftpenable)
nflag |= JPG_TO_FTP;
if(nflag){
JpgRun(nflag, 1 );
SemWait(pEvironment->hAlarmSem);
gSchJpgRun = 1;
SemRelease(pEvironment->hAlarmSem);
}
}
fSetSysLog(&tLog);
break;
}
case ALARM_EVENT_SCHEDULE_END:
{
int isFTPAVI;
int supportJPG=0,supportH264=0,supportH264cif=0,supportMpeg4=0,supportMpeg4cif=0,supportAVI=0;
DBG("ALARM_EVENT_SCHEDULE_END\n");
isFTPAVI=pSysInfo->ftp_config.ftpfileformat;
isFTPAVI=pSysInfo->ftp_config.ftpfileformat;
supportJPG = pSysInfo->lan_config.Supportstream1;
supportMpeg4 = pSysInfo->lan_config.Supportstream2;
supportMpeg4cif = pSysInfo->lan_config.Supportstream3;
supportH264 = pSysInfo->lan_config.Supportstream5;
supportH264cif = pSysInfo->lan_config.Supportstream6;
supportAVI = supportH264|supportH264cif|supportMpeg4|supportMpeg4cif;
if(pSysInfo->sdcard_config.sdinsert==3){
/* AVI no stop case */
SemWait(pEvironment->hAlarmSem);
if(!gbSD_WriteProtect && gSchAviRun){
AviStop();
gSchAviRun = 0;
}
if(gSchJpgRun){
JpgStop(1);
gSchJpgRun = 0;
}
SemRelease(pEvironment->hAlarmSem);
} else {
SemWait(pEvironment->hAlarmSem);
if(gSchAviRun){
AviStop();
gSchAviRun = 0;
}
if(gSchJpgRun){
JpgStop(0);
gSchJpgRun = 0;
}
SemRelease(pEvironment->hAlarmSem);
}
break;
}
default:
ERR("Unknown Event\n");
sprintf(tLog.event, "Unknown Event");
fSetSysLog(&tLog);
status = PROC_FAIL;
break;
}
ALARM_EXIT:
free(pEvironment);
DBG("Free evironment sucess\n");
pthread_exit(status);
return status;
}
/**
* @brief Restart scheduling.
*/
void ResumeSchedule()
{
SemWait(gSemSchedule);
gbSchedulePause = 0;
SemRelease(gSemSchedule);
}
/**
* @brief JPEG manager thread
* @param arg [I ] Not used.
* @return 0 on normal end.
*/
void *JpgMngThr(void *arg)
{
int nState, nSetFlg;
unsigned short nFlg;
while(!(GetJpgState(0) & JPG_THR_EXIT)){
JPG_DBG("Ready\n");
while(!((nState = GetJpgState(JPG_RUN | JPG_DST_MASK | JPG_STOP)) & (JPG_RUN | JPG_THR_EXIT))){
if(SemWait(hAlarmStatusSem) == 0){
nFlg = pSysinfo->lan_config.alarmstatus & (~FLG_UI_JPG);
if(!(nFlg & (FLG_UI_AVI | FLG_UI_JPG)))
nFlg &= (~FLG_UI_RECORD);
fSetAlarmStatus(nFlg);
SemRelease(hAlarmStatusSem);
}
JPG_DBG("JpgMngThr sleep\n");
pthread_cond_wait(&gJpgRunCond, &gJpgConMutex);
JPG_DBG("JpgMngThr Wake up\n");
}
if(JPG_THR_EXIT & nState)
break;
nSetFlg = 0;
if(!pSysinfo->lan_config.Supportstream1){
JPG_DBG("Jpeg stream not support\n");
continue;
}
if(SemWait(hAlarmStatusSem) == 0){
nFlg = pSysinfo->lan_config.alarmstatus | FLG_UI_JPG | FLG_UI_RECORD;
fSetAlarmStatus(nFlg);
SemRelease(hAlarmStatusSem);
}
JPG_DBG("Jpeg Run\n");
if((nState & JPG_DST_MASK) == 0){
JPG_ERR("Unknown jpeg file destination\n");
continue;
}
#if 0
if(nState & JPG_TO_SMTP)
DoJpegDispatch(NULL, JPG_DISPATCH_TO_SMTP);
if(nState & JPG_TO_FTP)
DoJpegDispatch(NULL, JPG_DISPATCH_TO_FTP);
if(nState & JPG_TO_SD)
SaveJpegToSD();
else
sleep(5);
#else
if(nState & JPG_TO_SMTP)
nSetFlg |= FILE_DISPATCH_TO_SMTP;
if(nState & JPG_TO_FTP)
nSetFlg |= FILE_DISPATCH_TO_FTP;
if(nState & JPG_TO_SD)
nSetFlg |= FILE_DISPATCH_TO_SD;
if(gFileDispCount < FILE_DISP_THR_LIMIT){
JPG_DBG("nSetFlg is 0x%x\n", nSetFlg);
SaveJpeg(nSetFlg);
} else
printf("Jpeg save limit \n");
#endif
}
JPG_DBG("Thread exit\n");
return (void *)0;
}
int SemHandleWait(sem_t sem) {
if (sem < 0) return SYNC_FAIL;
if (sem >= MAX_SEMS) return SYNC_FAIL;
if (!sems[sem].inuse) return SYNC_FAIL;
return SemWait(&sems[sem]);
}
