/*
Returns a pointer to the per-thread sys_timeouts structure. In lwIP,
each thread has a list of timeouts which is represented as a linked
list of sys_timeout structures. The sys_timeouts structure holds a
pointer to a linked list of timeouts. This function is called by
the lwIP timeout scheduler and must not return a NULL value.
In a single threaded sys_arch implementation, this function will
simply return a pointer to a global sys_timeouts variable stored in
the sys_arch module.
*/
struct sys_timeouts *
sys_arch_timeouts(void)
{
u8_t curr_prio;
s8_t ubldx;
OS_TCB curr_task_pcb;
null_timeouts.next = NULL;
OSTaskQuery(OS_PRIO_SELF,&curr_task_pcb);
curr_prio = curr_task_pcb.OSTCBPrio;
ubldx = (u8_t)(curr_prio - LWIP_START_PRIO);
if((ubldx>=0) && (ubldx<LWIP_TASK_MAX))
{
/* printf("\nlwip_timeouts[%d],prio=%d!!! \n",ubldx,curr_prio); */
return &lwip_timeouts[ubldx];
}
else
{
/* printf("\nnull_timeouts,prio=%d!!! \n",curr_prio); */
return &null_timeouts;
}
}
void DccParseTask_Print(void)
{
OS_TCB os_tdata;
OSTaskQuery(g_pDccParseTask->m_task.tid, &os_tdata);
DCC_TRACE(10, "%s : tid %03x msg %03x nSleep %2d bDelay %1d",
os_tdata.OSTCBTaskName,
g_pDccParseTask->m_task.tid,
g_pDccParseTask->m_task.msgQ.pHead,
g_pDccParseTask->m_task.nSleepCount,
g_pDccParseTask->m_bDelay
);
}
u_char TK_OSTaskQuery(void)
{
OS_TCB task_data;
INT8U err, task_prio;
err = OSTaskQuery(OS_PRIO_SELF, &task_data);
if (err == OS_NO_ERR)
{
task_prio = task_data.OSTCBPrio;
}
else
{
dprintf("ChronOS API call failure, unable to identify task!");
panic("TK_OSTaskQuery");
return 0;
}
return task_prio;
}
void GenericTask(void * pdata)
{
auto OS_TCB data;
OSTaskQuery(OS_PRIO_SELF, &data);
if (data.OSTCBPrio < 20)
DispStr((data.OSTCBPrio * 4) + 2, 7, "r");
if (data.OSTCBPrio >= 20 && data.OSTCBPrio < 40)
DispStr(((data.OSTCBPrio % 20) * 4) + 2, 10, "r");
if (data.OSTCBPrio >= 40 && data.OSTCBPrio < 60)
DispStr(((data.OSTCBPrio % 20) * 4) + 2, 13, "r");
while(1)
{
// check to see if deletion request registered, if so delete self
if (OSTaskDelReq(OS_PRIO_SELF) == OS_TASK_DEL_REQ)
OSTaskDel(OS_PRIO_SELF);
OSTimeDly(2);
}
}
static void KeyScan (void* pdata)
{
static INT32U backup_read = 0;
static INT8U judge_flag = 0;
static INT8U refresh_flag = 0;
static INT32U front_read = KEY_DEFAULT_STATE;
static INT32U current_read = KEY_DEFAULT_STATE;
INT32U new_read;
#if KEY_PUSH_EN == 1 || KEY_DOUBLE_EN == 1
static OS_TCB task_data;
#endif
while (1)
{
new_read = key_phy_read () & 0x00ffffff;
if (new_read == backup_read)
{
if (refresh_flag == 0)
{
front_read = current_read;
current_read = new_read;
refresh_flag = 1;
judge_flag = 1;
}
}
else
{
backup_read = new_read;
refresh_flag = 0;
}
if (judge_flag == 1)
{
change = front_read ^ current_read;
if (change)
{
if ((change & current_read) != 0)
{
key_hook (TYPE_KEY_UP<<24 | change);
OSQPost (os_q_key_msg, (void*)(TYPE_KEY_UP<<24 | change));
#if KEY_PUSH_EN == 1
if (OSTaskQuery (KEY_PUSH_TASK_PRIO, &task_data) == OS_NO_ERR)
{
OSSemPost (os_sem_push);
}
#endif
}
else
{
key_hook (TYPE_KEY_DOWN<<24 | change);
OSQPost (os_q_key_msg, (void*)(TYPE_KEY_DOWN<<24 | change));
#if KEY_PUSH_EN == 1
OSTaskCreate (PushKeyTask, (void*)0, &key_push_task_stk[KEY_PUSH_TASK_STK_SIZE - 1], KEY_PUSH_TASK_PRIO);
#endif
#if KEY_DOUBLE_EN == 1
if (OSTaskQuery (KEY_DOUBLE_TASK_PRIO, &task_data) == OS_NO_ERR)
{
OSSemPost (os_sem_double);
}
else
{
OSTaskCreate (DoubleKeyTask, (void*)0, &key_double_task_stk[KEY_DOUBLE_TASK_STK_SIZE - 1], KEY_DOUBLE_TASK_PRIO);
}
#endif
}
}
judge_flag = 0;
}
OSTimeDly (KEY_SCAN_INTERVAL);
}
}
void TaskTwoRiscSystemMonitorRisc0(void *data)
{
unsigned char err;
unsigned int msg;
unsigned short ret = 0;
OS_TCB tcb_data;
unsigned int temp;
unsigned int vstd = 0;
BspStartTicker(OS_TICKS_PER_SEC);
OSStatInit();
#ifdef PRINT_IN_TASK
print_init_buffer();
#ifdef CHIP_CFG_STACK_CHECK
OSTaskCreateExt(TaskTwoRiscPrint, (void *)0, (void *)&StkTaskTwoRiscPrint[sizeof(StkTaskTwoRiscPrint) / sizeof(StkTaskTwoRiscPrint[0]) - 1], PRIOR_TASK_PRINT,\
PRIOR_TASK_PRINT, (void *)&StkTaskTwoRiscPrint[0], sizeof(StkTaskTwoRiscPrint) / sizeof(StkTaskTwoRiscPrint[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR);
#else
OSTaskCreate(TaskTwoRiscPrint, (void *)0, (void *)&StkTaskTwoRiscPrint[STK_SIZE_TaskTwoRiscPrint - 1], PRIOR_TASK_PRINT);
#endif
#endif
printf("\r\n");
printf("**********************************************************************\r\n");
printf("* Risc%d: Two Risc System Monitor Task *\r\n", RiscRdID());
printf("**********************************************************************\r\n");
printf("\r\n");
#ifdef AUDIO_MODULE_INCLUDE
gptAudioTaskReady = 0;
#endif
#ifdef VIDEO_MODULE_INCLUDE
tVideoLinuxToUcos *pVideoPackage;
unsigned int VideoStatusBak;
unsigned int *pInt;
Risc_Packet_t risc_packet;
VideoStatusBak = 0;
gVideoStatus = 0;
/*******************************************************************
the code below is to fix the audio input channel 0 queue underflow bug,
details see bug number 5 in "avsyncbuglist.xls" in buglist.
*******************************************************************/
McScMap(VSC_RD_Y0_M, VSC_RD_Y0_S);
McScMap(VSC_RD_U0_M, VSC_RD_U0_S);
McScMap(VSC_RD_V0_M, VSC_RD_V0_S);
McScMap(VSC_RD_Y1_M, VSC_RD_Y1_S);
McScMap(VSC_RD_U1_M, VSC_RD_U1_S);
McScMap(VSC_RD_V1_M, VSC_RD_V1_S);
/*******************************************************************/
gtVinFormat.yuv_format = YUV420;
gtVinFormat.camera_format = NTSC; //0: NTSC mode, 1: PAL mode
if(gtVinFormat.camera_format == PAL) {
gtVinFormat.width = 704;
gtVinFormat.height = 576;
} else {
gtVinFormat.width = 704;
gtVinFormat.height = 480;
}
decode_flag = MPEG_ENCODE; //20071129;indicate the encode mode of the bit stream default is MPEG mode
#ifdef DVR
gChecksumEnabled = TRUE; // enable checksum
#else
gChecksumEnabled = FALSE; // please do not change the default value
#endif
#ifdef DVR
gImage_Mode = EVENODD_IMAGE;//MERGED_IMAGE;
#else
gImage_Mode = EVENODD_IMAGE;
#endif
gImgEncodeMode = ENCODEBOTH;
#endif
#ifdef DVR
MM74HC595Init();
#endif
gtPrintMsgControl.en_print_all_msg = 1;
gtPrintMsgControl.en_print_periodical_msg = 1;
memset((void *)>Statistics, 0, sizeof(gtStatistics));
/* David's email on Dec 12 to improve performance for video & mpeg */
*(volatile int *)0xa8040000 = 0x1680596;
*(volatile int *)0xa8020000 = 0x11115;
*(volatile int *)0xa8020004 = 0x0a77;
RiscIntrInit();
RiscFlagIntrInit();
IICinit();
TwoRiscCommInit();
#ifdef DUAL_CPU_MODE
RiscSemUnLock(7); // tell risc1 ISR table has been created!
#endif
gptQMsgTwoRiscSystemMonitor = OSQCreate(&ArrayQMsgSysMonitor[0], ArrayQMsgSysMonitor_MAX);
#ifdef VIDEO_MODULE_INCLUDE
gRvoDisplayMode = RVO_DISPLAY_BOTH;
gFreqFromCrystal = TRUE; //TRUE: external, FALSE:internal
gVoutClkSet = FALSE;
gCameraSelectDigital = TRUE;//TRUE:digital,FALSE:analog
extern unsigned int gVinOddEvenFrameSelect;
extern unsigned int gVscOddEvenFrameSelect;
gVinOddEvenFrameSelect = ODD_FRAME_FIRST;
#ifdef DVR
gVscOddEvenFrameSelect = ODD_FRAME_FIRST;
#else
gVscOddEvenFrameSelect = EVEN_FRAME_FIRST;
#endif
#ifdef MOTION_DETECTION //wy:motion detect init
gMotionSensi = 0; //default disable motion detection.
gIsMDEnabled = FALSE; //default disable motion detection.
gMdType = mdtemporalDif; //default motion detection method.
#endif
#ifdef BAND_WIDTH_CONTROL
set_cbr_default();
#endif
#ifdef AV_SYNC
set_avsync_default();
#endif
#ifdef DISPLAY_INCLUDE
#ifdef VIDEO_JITTER_BUFFER
QEeventVodeoL2U = OSQCreate(pQVideoL2UPackage, VIDEO_L2U_PKG_NUMBER);
if(QEeventVodeoL2U == NULL)
_PRINTF("\r\nxxxxxxxx: Risc0: OSQCreate QEeventVodeoL2U error!\r\n");
#endif
#ifdef STARTUP_PICTURE
err = OSQPost(gptQMsgTwoRiscSystemMonitor, (void *)TWO_RISC_SYSTEM_OPEN_VOUT);
if(err != OS_NO_ERR)
printf("\r\nRISC0: OSMboxPost error! err = %d!\r\n", err);
#endif
#endif
#endif
#ifdef TASK_STATISTIC_EN
if(
#ifdef CHIP_CFG_STACK_CHECK
OSTaskCreateExt(TaskStatistics, (void *)0, (void *)&StkTaskStatistics[sizeof(StkTaskStatistics) / sizeof(StkTaskStatistics[0]) - 1], PRIOR_TASK_STATISTICS,\
PRIOR_TASK_STATISTICS, (void *)&StkTaskStatistics[0], sizeof(StkTaskStatistics) / sizeof(StkTaskStatistics[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR) != OS_NO_ERR
#else
OSTaskCreate(TaskStatistics, (void *)0, (void *)&StkTaskStatistics[STK_SIZE_TaskStatistics - 1], PRIOR_TASK_STATISTICS) != OS_NO_ERR
#endif
)
{
debug ("\r\nTaskCreate TaskCount1s error\r\n");
}
#endif
//RiscTimerInit(1000000);
while(1) {
#if 0
//#ifdef VIDEO_JITTER_BUFFER
pVideoPackage = (tVideoLinuxToUcos *)OSQPend(QEeventVodeoL2U, 200 * OS_TICKS_PER_SEC /1000, &err);
if(err == OS_NO_ERR) {
VideoFrameReceive.addr = pVideoPackage->addr;
VideoFrameReceive.size = pVideoPackage->len;
VideoFrameReceive.TimeStamp = pVideoPackage->tstamp;
err = VBufSaveOneFrame(&VideoBuffer1, &VideoFrameReceive);
if(err)
printf("xxx save viedo frame to buffer error! err = %d\n", err);
else
{
//printf("depth = %d, space = %d\n", VideoFrameReceive.CurrentDepth, VideoFrameReceive.CurrentSpace);
//printf("w = 0x%8.8x, %d, %d\n", VideoFrameReceive.addr, VideoFrameReceive.size, VideoFrameReceive.TimeStamp);
}
RiscDecCNT(VIDEO_LINUX_TO_UCOS_CNT, 1);
if(OSSemPost(gptVideoLinuxToUcosMbox) != OS_NO_ERR)
printf("Risc0:OSMboxPost error!\r\n");
}
else if(err == OS_TIMEOUT)
;//printf("ucos receive video package time out!\n");
msg = (unsigned int)OSQAccept(gptQMsgTwoRiscSystemMonitor);
if(msg)
#else
msg = (unsigned int)OSQPend(gptQMsgTwoRiscSystemMonitor, 200 * OS_TICKS_PER_SEC /1000, &err);
if(err == OS_NO_ERR)
#endif
{
switch(msg) {
case TWO_RISC_SYSTEM_RECEIVE_LINUX_MSG:
while(1) {
if(TwoRiscCommRecPacket() != SUCCESSFUL) {
break;
}
}
break;
#ifdef VIDEO_MODULE_INCLUDE
#ifdef DISPLAY_INCLUDE
case TWO_RISC_SYSTEM_CLOSE_VOUT:
gVoutEnable = 0;
break;
case TWO_RISC_SYSTEM_CLOSE_DISPLAY_TASK:
gVoutEnable = 0;
printf("Close Display Task!\n");
//del task
if(OSTaskDel(PRIOR_TASK_DISPLAY) != OS_NO_ERR )
printf("OSTaskDel failed!\n");
else
printf("OSTaskDel OK!\n");
OSSemDel_w(gptMpegDecodeReadyToStart, OS_DEL_ALWAYS, &err);
OSSemDel_w(gptVideoLinuxToUcosMbox, OS_DEL_ALWAYS, &err);
#ifdef AV_SYNC
OSSemDel_w(gptRiscTimerIntrOccur, OS_DEL_ALWAYS, &err);
#endif
OSQDel(gptMpeg4DecodeOutputReady, OS_DEL_ALWAYS, &err);
if(err != OS_NO_ERR)
printf("OSQDel failed!\n");
#ifdef PIP_ENABLE
OSQDel (gptMqueueVideoInFrame, OS_DEL_ALWAYS, &err);
if(err != OS_NO_ERR)
printf("OSQDel failed, err = %d!", err);
gVideoStatus &= ~tPipEn;
#endif
break;
case TWO_RISC_SYSTEM_OPEN_VOUT:
if(OSTaskQuery(PRIOR_TASK_DISPLAY, &tcb_data) == OS_NO_ERR) {
//if(OSTaskCreate(TaskTwoRiscDisplay, (void *)0, (void *)&StkTaskTwoRiscDisplay[STK_SIZE_TaskTwoRiscDisplay - 1], PRIOR_TASK_DISPLAY) != OS_NO_ERR) {
if(gVoutEnable == 0) {
gVoutEnable = 1;
GetVoutInterface();
VoutInterfaceIntialize(gtDisplayFormat.vout_format);
/*
printf("Init 7171 ");
if(HwADV7171Initialize(gtDisplayFormat.vout_format) == SUCCESSFUL) // 0: NTSC mode,1: pal mode
printf("ok\n");
else
printf("failed\n");
*/
if(gtDisplayFormat.vout_format == LCD) {
gtDisplayFormat.vout_interlaced = FALSE;
} else { // NTSC or PAL
gtDisplayFormat.vout_interlaced = TRUE;
}
#ifdef OSD_ENABLE
unsigned int task_rollstr_flag = 0;
if(gtOsdCurrent.osd_format!=gtDisplayFormat.vout_format){
if(OSTaskQuery(PRIOR_TASK_ROLLSTR, &tcb_data) == OS_NO_ERR){
task_rollstr_flag = 1;
if(OSTaskDel(PRIOR_TASK_ROLLSTR) != OS_NO_ERR )
debug("OSTaskDel(PRIOR_TASK_ROLLSTR) failed!\n");
}
if(gtDisplayFormat.vout_format == NTSC){
gtOsdCurrent.osd_format = NTSC;
gtOsdCurrent.width = 704;
gtOsdCurrent.height = 480;
} else if(gtDisplayFormat.vout_format == PAL){
gtOsdCurrent.osd_format = PAL;
gtOsdCurrent.width = 704;
gtOsdCurrent.height = 576;
} else if(gtDisplayFormat.vout_format == LCD){
gtOsdCurrent.osd_format = LCD;
gtOsdCurrent.width = 480;
gtOsdCurrent.height = 240;
}
//printf("\ngtOsdCurrent.width=%d,gtOsdCurrent.height=%d\n", gtOsdCurrent.width, gtOsdCurrent.height);
gtOsdCurrent.start_pixel = 0;
gtOsdCurrent.start_line = 0;
gtOsdCurrent.backgroundColor = 15;
gtOsdCurrent.OSD_T_Mask = 15;
gtOsdCurrent.fill_addr = (((unsigned int)OSD_memory_0)&0x1fffffff);
gtOsdCurrent.display_addr = (((unsigned int)OSD_memory_0)&0x1fffffff);
InitOsdMemory(gtOsdCurrent.start_pixel ,gtOsdCurrent.start_line, gtOsdCurrent.width, gtOsdCurrent.height , gtOsdCurrent.backgroundColor, gtOsdCurrent.fill_addr, gtOsdCurrent.OSD_T_Mask);
if(task_rollstr_flag == 1){
if(
#ifdef CHIP_CFG_STACK_CHECK
OSTaskCreateExt(TaskRollString, (void *)0, (void *)&StkTaskRollStr[sizeof(StkTaskRollStr) / sizeof(StkTaskRollStr[0]) - 1], PRIOR_TASK_ROLLSTR,\
PRIOR_TASK_ROLLSTR, (void *)&StkTaskRollStr[0], sizeof(StkTaskRollStr) / sizeof(StkTaskRollStr[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR) != OS_NO_ERR
#else
OSTaskCreate(TaskRollString, (void *)0, (void *)&StkTaskRollStr[STK_SIZE_ROLLSTR - 1], PRIOR_TASK_ROLLSTR) != OS_NO_ERR
#endif
)
debug ("\r\nTaskCreate TaskRollString error!\r\n");
else{
debug("\r\nTaskCreate TaskRollString OK!\r\n");
}
}
}
#endif
VscInit();
AppVscStart();
gVideoStatus |= tVoutEn;
}
} else {
TwoRiscDisplayRvoPipOsdInit();
if(
#ifdef CHIP_CFG_STACK_CHECK
OSTaskCreateExt(TaskTwoRiscDisplay, (void *)0, (void *)&StkTaskTwoRiscDisplay[sizeof(StkTaskTwoRiscDisplay) / sizeof(StkTaskTwoRiscDisplay[0]) - 1], PRIOR_TASK_DISPLAY,\
PRIOR_TASK_DISPLAY, (void *)&StkTaskTwoRiscDisplay[0], sizeof(StkTaskTwoRiscDisplay) / sizeof(StkTaskTwoRiscDisplay[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR) != OS_NO_ERR
#else
OSTaskCreate(TaskTwoRiscDisplay, (void *)0, (void *)&StkTaskTwoRiscDisplay[STK_SIZE_TaskTwoRiscDisplay - 1], PRIOR_TASK_DISPLAY) != OS_NO_ERR
#endif
)
printf("\r\nTaskTwoRiscDisplay create error!\r\n");
}
break;
case TWO_RISC_SYSTEM_CLOSE_PIP:
gPipEnable = 0;
break;
case TWO_RISC_SYSTEM_CLOSE_RVO:
gRvoEnable = 0;
break;
case TWO_RISC_SYSTEM_CLOSE_OSD:
gOsdEnable = 0;
break;
case TWO_RISC_SYSTEM_OPEN_RVO:
if(gRvoEnable == 0) {
if(gVoutEnable == 1) {
gVoutReEnable = 1;
}
gRvoEnable = 1;
}
break;
case TWO_RISC_SYSTEM_OPEN_PIP:
if(gPipEnable == 0) {
if(gVoutEnable == 1) {
gVoutReEnable = 1;
}
gPipEnable = 1;
}
break;
#ifdef OSD_ENABLE
case TWO_RISC_SYSTEM_OPEN_OSD:
if(gOsdEnable==0) {
if(gVoutEnable == 1)
gVoutReEnable = 1;
gOsdEnable =1;
}
/*if (OSTaskCreate(TaskRollString, (void *)0, (void *)&StkTaskRollStr[STK_SIZE_ROLLSTR - 1], PRIOR_TASK_ROLLSTR) != OS_NO_ERR)
{
debug ("\r\nTaskCreate TaskRollString error!\r\n");
} else
printf("\r\nTaskCreate TaskRollString succed!\r\n");*/
break;
#endif
#endif
case TWO_RISC_SYSTEM_OPEN_VIN:
#ifdef CHIP_CFG_STACK_CHECK
OSTaskCreateExt(TaskTwoRiscVinMpegEncode, (void *)0, (void *)&StkTaskTwoRisc0IPCamera[sizeof(StkTaskTwoRisc0IPCamera) / sizeof(StkTaskTwoRisc0IPCamera[0]) - 1], PRIOR_TASK_IPCAM,\
PRIOR_TASK_IPCAM, (void *)&StkTaskTwoRisc0IPCamera[0], sizeof(StkTaskTwoRisc0IPCamera) / sizeof(StkTaskTwoRisc0IPCamera[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR);
#else
OSTaskCreate(TaskTwoRiscVinMpegEncode, (void *)0, (void *)&StkTaskTwoRisc0IPCamera[TaskTwoRiscMpegEncode_STK_SIZE - 1], PRIOR_TASK_IPCAM);
#endif
#ifdef CHIP_CFG_STACK_CHECK
OSTaskCreateExt(TaskTwoRiscSendMpegH263Encode, (void *)0, (void *)&StkTaskTwoRiscSendMpegH263Encode[sizeof(StkTaskTwoRiscSendMpegH263Encode) / sizeof(StkTaskTwoRiscSendMpegH263Encode[0]) - 1], PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE,\
PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE, (void *)&StkTaskTwoRiscSendMpegH263Encode[0], sizeof(StkTaskTwoRiscSendMpegH263Encode) / sizeof(StkTaskTwoRiscSendMpegH263Encode[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR);
#else
OSTaskCreate(TaskTwoRiscSendMpegH263Encode, (void *)0, (void *)&StkTaskTwoRiscSendMpegH263Encode[TaskTwoRiscSendMpegh263Encode_STK_SIZE - 1], PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE);
#endif
break;
case TWO_RISC_SYSTEM_REOPEN_VIN_TASK:
{
INT8U dret = 0;
DIS_VIN_VIDEO();
debug("before OSTaskDel(PRIOR_TASK_IPCAM).\n");
OSTaskDel(PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE);
dret = OSTaskDel(PRIOR_TASK_IPCAM);
debug("after OSTaskDel(PRIOR_TASK_IPCAM).\n");
if (dret != OS_NO_ERR )
debug("OSTaskDel(PRIOR_TASK_IPCAM) failed.\n");
else
debug("OSTaskDel(PRIOR_TASK_IPCAM) success.\n");
OSSemDel_w(gptSemMpegEncodeReady, OS_DEL_ALWAYS, &err);
OSSemDel_w(gptSemMp4EncodeOutBufReady, OS_DEL_ALWAYS, &err);
OSMboxDel_w(gptMboxVideoInFrame, OS_DEL_ALWAYS, &err);
OSMboxDel_w(gptMboxMpegEncodeOutFrame, OS_DEL_ALWAYS, &err);
gVideoStatus &= ~tVinEn;
#if 0
#ifdef PIP_ENABLE
OSQDel (gptMqueueVideoInFrame, OS_DEL_ALWAYS, &err);
if(err != OS_NO_ERR)
printf("OSQDel failed, err = %d!", err);
#endif
#endif
#ifdef CHIP_CFG_STACK_CHECK
OSTaskCreateExt(TaskTwoRiscVinMpegEncode, (void *)0, (void *)&StkTaskTwoRisc0IPCamera[sizeof(StkTaskTwoRisc0IPCamera) / sizeof(StkTaskTwoRisc0IPCamera[0]) - 1], PRIOR_TASK_IPCAM,\
PRIOR_TASK_IPCAM, (void *)&StkTaskTwoRisc0IPCamera[0], sizeof(StkTaskTwoRisc0IPCamera) / sizeof(StkTaskTwoRisc0IPCamera[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR);
#else
OSTaskCreate(TaskTwoRiscVinMpegEncode, (void *)0, (void *)&StkTaskTwoRisc0IPCamera[TaskTwoRiscMpegEncode_STK_SIZE - 1], PRIOR_TASK_IPCAM);
#endif
#ifdef CHIP_CFG_STACK_CHECK
OSTaskCreateExt(TaskTwoRiscSendMpegH263Encode, (void *)0, (void *)&StkTaskTwoRiscSendMpegH263Encode[sizeof(StkTaskTwoRiscSendMpegH263Encode) / sizeof(StkTaskTwoRiscSendMpegH263Encode[0]) - 1], PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE,\
PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE, (void *)&StkTaskTwoRiscSendMpegH263Encode[0], sizeof(StkTaskTwoRiscSendMpegH263Encode) / sizeof(StkTaskTwoRiscSendMpegH263Encode[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR);
#else
OSTaskCreate(TaskTwoRiscSendMpegH263Encode, (void *)0, (void *)&StkTaskTwoRiscSendMpegH263Encode[TaskTwoRiscSendMpegh263Encode_STK_SIZE - 1], PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE);
#endif
}
break;
case TWO_RISC_SYSTEM_DEL_VIN_TASK:
DIS_VIN_VIDEO();
INT8U dret = 0;
debug("before OSTaskDel(PRIOR_TASK_IPCAM).\n");
OSTaskDel(PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE);
dret = OSTaskDel(PRIOR_TASK_IPCAM);
debug("after OSTaskDel(PRIOR_TASK_IPCAM).\n");
if (dret != OS_NO_ERR )
debug("OSTaskDel(PRIOR_TASK_IPCAM) failed.\n");
else
debug("OSTaskDel(PRIOR_TASK_IPCAM) success.\n");
OSSemDel_w(gptSemMpegEncodeReady, OS_DEL_ALWAYS, &err);
OSSemDel_w(gptSemMp4EncodeOutBufReady, OS_DEL_ALWAYS, &err);
OSMboxDel_w(gptMboxVideoInFrame, OS_DEL_ALWAYS, &err);
OSMboxDel_w(gptMboxMpegEncodeOutFrame, OS_DEL_ALWAYS, &err);
gVideoStatus &= ~tVinEn;
break;
#endif /*VIDEO_MODULE_INCLUDE*/
#ifdef DVR
/* wg add for DVR 2007.08.16 */
case TWO_RISC_SYSTEM_DVR_READ_MOTION_DETECTION:
Hw2835ReadMDRegister();
#endif
break;
#ifdef VIDEO_MODULE_INCLUDE
case TWO_RISC_SYSTEM_SET_CLOCK:
if(gFreqFromCrystal == FALSE) {
printf("\nTaskTwoRiscVinMpegEncode: camera clock is created from Vout!\n");
CctlVoutClkSet();
} else {
printf("\nTaskTwoRiscVinMpegEncode: camera clock is created from external crystal!\n");
CctlVoutClkSet();
}
gCameraSelectDigital = -1; //initialize it to avoid default FALSE
pcurrent_camera = GetDigitCamera();
if(pcurrent_camera) {
gCameraSelectDigital = TRUE;
}else {
pcurrent_camera = GetAnalogCamera();
if(pcurrent_camera) {
gCameraSelectDigital = FALSE;
if(pcurrent_camera != NULL) //has found digital camera or 7181
pcurrent_camera->camera_init();
else { //
printf("\nTaskTwoRiscVinMpegEncode: no analog cameras found!\n");
}
if(pcurrent_camera->GetCamVideoStd) { //is the chip support video standard detection?
if(pcurrent_camera->GetCamVideoStd(&vstd) == SUCCESSFUL) { //get analog camera and video standard
if((gtVinFormat.camera_format != vstd)) {
gtVinFormat.camera_format = vstd;
}
}
}
}
}
break;
#endif
default:
printf("\nTaskTwoRiscSystemMonitorRisc0: type(%d) error!\n", msg);
break;
}
}
#ifdef VIDEO_MODULE_INCLUDE
#ifdef DISPLAY_INCLUDE
if(gVoutEnable == 0)
gVideoStatus &= ~tVoutEn;
#endif
if(VideoStatusBak != gVideoStatus)
{
debug("\n>>>>>>>>>>>>>>>>>>\n");
VideoStatusBak = gVideoStatus;
//don't send gVideoStatus, it will be change in other task while you send!
pInt = (unsigned int *)&risc_packet;
risc_packet.start = RISC_PKT_START;
risc_packet.main_type = tVideo;
risc_packet.sub_type = tCheckVideoStatus;
risc_packet.length = 0x8;
risc_packet.status = 0;
*(pInt + 2) = VideoStatusBak;
risc_packet.end = RISC_PKT_END;
if(TwoRiscCommSendPacket((unsigned int *)&risc_packet, RPACKET_LEN) == SUCCESSFUL)
RiscFlagSet(); // Set risc1 flag to interrupt risc1
else
debug("\r\nSend Video Status error!\r\n");
}
#endif /* VIDEO_MODULE_INCLUDE */
}
}
