void TaskUart(void *pdata) //send message to uart from uartQ
{
INT8U *pUartMsg;
INT8U err;
pdata=pdata;
Uart_Printf("taskuart\n");
while(1)
{
// 进程taskuart不断地用pUart_Q里读数据，当有数据时，则进行打印。
pUartMsg=OSQAccept(pUart_Q,&err);//Accept the Msg from Qene; no wait
while(pUartMsg)
{
// Uart_Printf("get msg\n");
Uart_SendString(pUartMsg);//seng str to Uart
OSMemPut(pUartMem,pUartMsg);
pUartMsg=OSQAccept(pUart_Q,&err);//free Mem
}
OSTimeDly(OS_TICKS_PER_SEC/5);
}
}
//========================================================
//Function Name:msgQAccept
//Syntax: INT32S msgQAccept(MSG_Q_ID msgQId, INT32U *msg_id, void *para, INT32U maxParaNByte)
//Purpose: Check whether a message is available from a message queue
//Note:
//Parameters: MSG_Q_ID msgQId /* message queue on which to send */
// INT32U *msg_id /* message id */
// void *para /* message and type received */
// INT32U maxNByte /* message size */
//Return: -1: queue is empty or fail
// 0: success
//=======================================================
INT32S msgQAccept(MSG_Q_ID msgQId, INT32U *msg_id, void *para, INT32U maxParaNByte)
{
INT8U err;
void *pMsg;
pMsg = OSQAccept(msgQId->pEvent, &err);
if (err!=OS_NO_ERR || !pMsg) {
return -1;
}
MSG_Q_LOCK();
if (maxParaNByte > msgQId->maxMsgLength) {
MSG_Q_UNLOCK();
#if MSG_Q_DEBUG == 1
DBG_PRINT("msg receive err:message size is too large\r\n");
#endif
return -1;
}
*msg_id = *((INT32U *) pMsg);
if (maxParaNByte && para) {
gp_memcpy((INT8S *) para, (INT8S *) pMsg + 4, maxParaNByte);
}
*(INT32U *) pMsg = 0; /* free message */
MSG_Q_UNLOCK();
return 0;
}
/*********************************************************************************************************
** Function name: zyMsgAccept
** Descriptions: 无等待获得消息
** input parameters: ulMsg: zyMsgCreate返回值
** output parameters: pucMsg: 保存获得的消息
** Returned value: ZY_OK: 成功
** 负数: 错误,绝对值参考zy_if.h
** Created by: Chenmingji
** Created Date: 2009-07-23
**--------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date:
*********************************************************************************************************/
INT32S zyMsgAccept (unsigned long ulMsg, INT8U *pucMsgRt)
{
__ZY_IF_MSG *pimThis; /* 消息通道信息 */
void *pvTmp;
pimThis = (__ZY_IF_MSG *)ulMsg;
/*
* 参数检查
*/
if (ulMsg == 0) {
return -ZY_PARAMETER_ERR;
}
#if OS_ARG_CHK_EN == 0
if (pimThis->poeQ == NULL) {
return -ZY_PARAMETER_ERR;
}
if (pimThis->pomMsg == NULL) {
return -ZY_PARAMETER_ERR;
}
#endif /* OS_ARG_CHK_EN */
pvTmp = OSQAccept(pimThis->poeQ);
if (pvTmp == NULL) {
return -ZY_NOT_OK;
}
memcpy(pucMsgRt, pvTmp, (size_t)(pimThis->ulMsgSize)); /* 拷贝数据 */
OSMemPut(pimThis->pomMsg, pvTmp); /* 归还缓冲区 */
return ZY_OK;
}
void TaskUart(void *pdata) //send message to uart from uartQ
{
char *pUartMsg;
INT8U err;
pdata=pdata;
while(1)
{
pUartMsg=OSQAccept(pUart_Q,&err);//Accept the Msg from Qene; no wait
while(pUartMsg)
{
Uart_SendString(pUartMsg);//seng str to Uart
OSMemPut(pUartMem,pUartMsg);
pUartMsg=OSQAccept(pUart_Q,&err);//free Mem
}
OSTimeDly(OS_TICKS_PER_SEC/5);
}
}
/*
*******************************************************************************
**
** This function waits until a message is available in the given mailqueue.
** The suspend argument controls whether this function will be in blocking
** mode or not while waiting for a message. A waiting message will be cleared.
**
*******************************************************************************
*/
RTOS_Message RTOS_MailqueueWait( RTOS_Mailqueue mailqueue, RTOS_Flag suspend )
{
INT8U error = OS_NO_ERR;
void* message = 0;
if( ! RTOS_MailqueueIsValid( mailqueue ) )
return( (RTOS_Message)0 );
if( suspend )
message = OSQPend( (OS_EVENT*)mailqueue, (INT16U)0, &error );
else
message = OSQAccept( (OS_EVENT*)mailqueue );
if( ( error != OS_NO_ERR ) || ( message == 0 ) )
return( (RTOS_Message)0 );
return( message );
}
/*FUNCTION**********************************************************************
*
* Function Name : OSA_MsgQGet
* Description : This function checks the queue's status, if it is not empty,
* get message from it and return kStatus_OSA_Success, otherwise, timeout will
* be used for wait. The parameter timeout indicates how long should wait in
* milliseconds. Pass OSA_WAIT_FOREVER to wait indefinitely, pass 0 will return
* kStatus_OSA_Timeout immediately if queue is empty.
* This function returns kStatus_OSA_Success if message is got successfully,
* returns kStatus_OSA_Timeout if message queue is empty within the specified
* 'timeout', returns kStatus_OSA_Error if any errors occur during waiting.
*
*END**************************************************************************/
osa_status_t OSA_MsgQGet(msg_queue_handler_t handler,
void *pMessage,
uint32_t timeout)
{
INT8U err;
void* localMsg;
int32_t *from_ptr, *to_ptr;
uint16_t msg_size = handler->size;
if (0U != timeout)
{
/* If timeout is not 0, convert it to tickes. */
timeout = wait_timeout_msec_to_tick(timeout);
localMsg = OSQPend(handler->pQueue, timeout, &err);
}
else
{
localMsg = OSQAccept(handler->pQueue, &err);
}
if (OS_ERR_NONE == err)
{
/* Copy localMsg to msg */
to_ptr = (int32_t*)(pMessage);
from_ptr = (int32_t*)localMsg;
while (msg_size--)
{
*to_ptr++ = *from_ptr++;
}
OSMemPut(handler->pMem, localMsg);
return kStatus_OSA_Success;
}
else if ((OS_ERR_Q_EMPTY == err) ||
(OS_ERR_TIMEOUT == err))
{
return kStatus_OSA_Timeout;
}
else
{
return kStatus_OSA_Error;
}
}
void gd_task_network(void *parg)
{
INT8S res = 0;
INT8U err;
gd_msg_t *recv_msg = NULL;
gd_network_task_t *network_task = &gd_system.network_task;
fail_tick = 0;
while(1)
{
recv_msg = (gd_msg_t *)OSQAccept(network_task->q_network, &err);
if(recv_msg != NULL)
{
switch(recv_msg->type)
{
case GD_MSG_GM_RESET:
network_gm_reset();
break;
case GD_MSG_GM_INIT:
network_gm_init();
break;
case GD_MSG_TCP_INIT:
network_tcpip_init();
break;
case GD_MSG_TCP_MODE_INIT:
network_tcpip_mode();
break;
case GD_MSG_TCP_CONNECT:
network_tcpip_creat();
break;
case GD_MSG_SEND_HEARTBEAT:
network_heart_beat();
break;
case GD_MSG_GM_NO_SIGNAL:
network_no_signal();
break;
/*unrequest at command*/
case GD_MSG_GM_TCP_LINK1_CLOSE:
network_tcpip_state_change(GM_TCPIP_LINK1_CLOSE);
break;
case GD_MSG_GM_TCP_LINK2_CLOSE:
network_tcpip_state_change(GM_TCPIP_LINK2_CLOSE);
break;
case GD_MSG_GM_TCP_LINK3_CLOSE:
network_tcpip_state_change(GM_TCPIP_LINK3_CLOSE);
break;
case GD_MSG_GM_TCP_SERVER_CLOSE:
network_tcpip_state_change(GM_TCPIP_SERVER_CLOSE);
break;
case GD_MSG_GM_TCP_CLOSE:
network_tcpip_state_change(GM_TCPIP_CLOSE);
break;
case GD_MSG_GM_RECV_SMS:
network_wakeup(GM_TCPIP_RECEIVED_SMS);
break;
case GD_MSG_GM_RECV_RING:
network_wakeup(GM_TCPIP_RECEIVED_RING);
break;
default:
break;
}
res = OSMemPut(gd_system.gd_msg_PartitionPtr, (void*)recv_msg);
if(res != OS_ERR_NONE)
{
//...error....
}
}
network_heart_beat();
OSTimeDlyHMSM(0, 0, 0, 100);
}
}
/*
*********************************************************************************************************
* App_TaskNoah_Ruler()
*
* Description : Process Comminucation between Ruler module and Audio Bridge.
* Noah protocol layer related data parsing and processing.
* This task wait for message event from App_TaskUART_Rx(). Check if the Noah layer data is
* valid in the message.
*
* Argument(s) : p_arg Argument passed to 'App_TaskNoah_Ruler()' by 'OSTaskCreate()'.
*
* Return(s) : none.
*
* Note(s) : (1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
* used. The compiler should not generate any code for this statement.
*********************************************************************************************************
*/
void App_TaskNoah_Ruler( void *p_arg )
{
(void)p_arg;
NOAH_CMD *pPcCmd ;
CPU_INT08U *pCmdBuf ;
CPU_INT08U rxID ;
CPU_INT08U PcCmdRxID_Ruler[4];
CPU_INT08U sum ;
CPU_INT08U SessionDone;
CPU_INT08U err ;
CPU_INT08U *pTaskMsgIN ;
CPU_INT08U *pMsg ;
pTaskMsgIN = NULL;
pMsg = NULL;
SessionDone = 0 ;
while( DEF_TRUE ) {
pTaskMsgIN = (INT8U *)OSQPend( EVENT_MsgQ_RulerUART2Noah, 0, &err );
if( pTaskMsgIN != NULL && OS_ERR_NONE == err ) {
pCmdBuf = pTaskMsgIN; // char point to the data buffer
pPcCmd = (NOAH_CMD *)pCmdBuf ; //change to NOAH_CMD type
rxID = GET_FRAME_ID( pPcCmd->head ) ; //get frame ID, index
sum = pPcCmd->checkSum; //get check sum data
LED_Toggle(LED_DS2);
APP_TRACE_DBG(("\r\n<<"));
switch( GET_FRAME_TYPE( pPcCmd->head ) ) {// GET_FRAME_TYPE(pPcCmd->head) get frame type
case FRAM_TYPE_DATA :
if( (sum == 0) || ( sum == CheckSum(0,pCmdBuf, pPcCmd->DataLen + 2)) ) {
// APP_TRACE_INFO(("R[%d]:[0x%2x>0x%2x][",Global_Ruler_Index,PcCmdRxID_Ruler[Global_Ruler_Index],rxID));
// for(unsigned int i = 0; i<pPcCmd->DataLen; i++){
// APP_TRACE_INFO((" %2X", *(unsigned char*)(pPcCmd->Data+i) ));
// }
// APP_TRACE_INFO((" ]\r\n"));
pcSendDateToBuf( EVENT_MsgQ_Noah2RulerUART, SET_FRAME_HEAD(rxID,FRAM_TYPE_ACK), NULL, 0, 0, NULL, 0 ) ; // ACK
if( (CPU_INT08U)(PcCmdRxID_Ruler[Global_Ruler_Index]+0x40) == rxID ) { // chweck if frameID repeat
PcCmdRxID_Ruler[Global_Ruler_Index] = rxID ; //save this frameID
err = Noah_CMD_Parse_Ruler( pPcCmd, &SessionDone); // jump to CMD parse
if( (err != OS_ERR_NONE) || (SessionDone == 1) ) {
SessionDone = 0;
Ruler_CMD_Result = err ;
OSTimeDly(2); //wait enough time for ACK to be sent
APP_TRACE_DBG((" Res[0x%2x]", Ruler_CMD_Result));
OSSemPost( Done_Sem_RulerUART );
}
} else {
APP_TRACE_DBG(("PcCmdRxID_Ruler[%d] Err: expect 0x%X, get 0x%X",Global_Ruler_Index,PcCmdRxID_Ruler[Global_Ruler_Index]+0x40,rxID));
}
} else {
pcSendDateToBuf( EVENT_MsgQ_Noah2RulerUART, SET_FRAME_HEAD(rxID,FRAM_TYPE_NAK), NULL, 0, 0, NULL, 0 ) ; // NAK
}
break ;
case FRAM_TYPE_ESTA :
PcCmdRxID_Ruler[Global_Ruler_Index] = 0xC0 ; // ? why 0x40: make sure there can be many same setup frame
PcCmdTxID_Ruler[Global_Ruler_Index] = 0x00 ; //
OSSemPost( ACK_Sem_RulerUART );
OSSemPost( Done_Sem_RulerUART ); //end the resend pending--
OSTimeDly(1); //wait for the TX buffer is empty
//Reset all UART CMD related buffer and release mem
do{ //reset mem used by EVENT_MsgQ_RulerUART2Noah
pMsg = (INT8U *)OSQAccept( EVENT_MsgQ_Noah2RulerUART, &err );
OSMemPut( pMEM_Part_MsgUART, pMsg );
} while ( pMsg != NULL && OS_ERR_NONE == err ) ;
do{ //reset mem used by EVENT_MsgQ_RulerUART2Noah
pMsg = (INT8U *)OSQAccept( EVENT_MsgQ_RulerUART2Noah, &err );
OSMemPut( pMEM_Part_MsgUART, pMsg );
} while ( pMsg != NULL && OS_ERR_NONE == err ) ;
Queue_Flush( pUART_Send_Buf[RULER_UART] ); //clear uart send&rec data queue
Queue_Flush( pUART_Rece_Buf[RULER_UART] );
SessionDone = 0; //init
OSSemSet( ACK_Sem_RulerUART, 0, &err ); // clear the sem
OSSemSet( Done_Sem_RulerUART, 0, &err );
test_counter4++;
APP_TRACE_DBG(("EST/ESTA"));
break ;
case FRAM_TYPE_ACK :
if( rxID == PcCmdTxID_Ruler[Global_Ruler_Index] ) {
OSSemPost( ACK_Sem_RulerUART );
test_counter2++;
} else {
APP_TRACE_INFO_T(("\r\nACK: Got %X, Expect %X\r\n",rxID,PcCmdTxID_Ruler[Global_Ruler_Index] ));
}
APP_TRACE_DBG(("ACK"));
test_counter3++;
break ;
case FRAM_TYPE_NAK :
// dismiss NAK, there will be a resend if no ACK got
// OSSemPost( Done_Sem_RulerUART );
test_counter1++;
APP_TRACE_DBG(("NAK"));
break;
default :
break ;
}
//release mem
OSMemPut( pMEM_Part_MsgUART, pTaskMsgIN );
}
////OSTimeDly(2); //use OSQPend(), no delay needed!!!
}
}
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 */
}
}
// Non-blocking waiting on a message queue
bool PeekOn(Queue queue)
{
INT8U err;
OSQAccept(queue, &err);
return err == OS_ERR_NONE;
}
