void video_async_file_unlink (char *filename,uint8 filelength)
{
uint8 FreeFilehandle;
boolean FileHandleFound = FALSE;
/*Check if Async Task is runing*/
if(init_complete == 1)
{
for(FreeFilehandle=0;FreeFilehandle<MAX_FILE_CLOSE_SIZE;FreeFilehandle++)
{
if(filenames [FreeFilehandle].used == 0)
{
FileHandleFound = TRUE;
break;
}
}
ASSERT (FileHandleFound);
ASSERT (filelength < MAX_FILE_NAME_SIZE);
filenames [FreeFilehandle].used = 1;
memcpy (filenames [FreeFilehandle].filename,filename,filelength);
filenames [FreeFilehandle].filename[filelength] = '\0';
(void)rex_set_sigs ( &video_async_tcb, /* tcb for which the sigs will be set */
VIDEO_ASYNC_SIG_FILEUNLINK /* the sigs to set */
);
}
/*If Async Task has not been initialized delete file immediately*/
else
{
efs_unlink (filename);
}
}
void video_async_file_close (VIDEO_ENG_FILE *fs_handle)
{
uint8 FreeFilehandle;
boolean FileHandleFound = FALSE;
/*Check if Async Task is initialized*/
if(init_complete == 1)
{
for(FreeFilehandle=0;FreeFilehandle<MAX_FILE_CLOSE_SIZE;FreeFilehandle++)
{
if(fs_handle_close [FreeFilehandle] == NULL)
{
FileHandleFound = TRUE;
break;
}
}
ASSERT (FileHandleFound);
fs_handle_close [FreeFilehandle] = fs_handle;
(void)rex_set_sigs ( &video_async_tcb, /* tcb for which the sigs will be set */
VIDEO_ASYNC_SIG_FILECLOSE /* the sigs to set */
);
}
/*If Async Task has not been initialized close file handle immediately*/
else
{
video_eng_file_fclose (fs_handle);
}
}
void video_aysnc_request_complete(rex_tcb_type * tcb, uint32 sig)
{
if (tcb == NULL)
{
return;
}
if (init_complete == 1)
{
video_async_client_tcb = tcb;
video_async_client_sig = sig;
(void) rex_set_sigs(&video_async_tcb,
VIDEO_ASYNC_SIG_REQ_COMPLETE
);
}
else
{
(void)rex_set_sigs(tcb,sig);
}
}
void db_setuiminitmask(byte mask)
{
// 如果已经在初始化状态，则不发送SIGNAL
MSG_FATAL("db_setuiminitmask 0x%x 0x%x",mask,db_uiminitmask,0);
if(db_uiminitmask)
{
db_uiminitmask = (db_uiminitmask | mask);
return;
}
db_uiminitmask = (db_uiminitmask | mask);
(void)rex_set_sigs(&uim_tcb, UIMDATA_INIT_SIG);
}
rce_nde_p rce_nfy_sig_rex(rce_nde_p nde_p, rce_nfy_p nfy_p)
{
if (RCE_NULL != nfy_p)
{
RCEVT_SIGEX_SIGREX* sigex_p = (RCEVT_SIGEX_SIGREX*)(&(nfy_p->sigex));
rce_nde_p rc = RCE_NULL;
rex_set_sigs(sigex_p->signal, sigex_p->mask);
rc = nde_p;
return rc;
}
else
{
ERR_FATAL("null handle use", 0, 0, 0);
return RCE_NULL;
}
}
void ds_put_cmd
(
ds_cmd_type *cmd_ptr /* Pointer to command to be sent */
)
{
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
/*-------------------------------------------------------------------------
Put the command on the command queue, and set the command queue signal.
-------------------------------------------------------------------------*/
q_put( &dsi_cmd_q, &cmd_ptr->hdr.link );
(void)rex_set_sigs( &ds_tcb, DS_CMD_Q_SIG );
} /* ds_put_cmd() */
void mccrxtx_cmd
(
mccrxtx_cmd_type *cmd_ptr /* Pointer to MCCRXTX message buffer */
)
{
#ifdef FEATURE_MC_QUEUE_WATERMARK
/* Usually RXTX takes a free buffer from MCC_RXTX_FREE_Q and */
/* put it onto mcc_rxtx_q by calling the function. It also */
/* takes a free buffer from MC_CMD_FREE_Q. So we need to */
/* update watermark for both these queues. */
mc_update_watermark(MCWM_CMD_FREE_Q);
mc_update_watermark(MCWM_RXTX_FREE_Q);
#endif
/* Set the request status to busy. initialize and link the command */
/* onto the MC command queue, set a signal to the MC task and exit. */
cmd_ptr->hdr.status = MCCRXTX_BUSY_S;
(void) q_link(cmd_ptr, &cmd_ptr->hdr.cmd_hdr.link);
q_put(&mcc_rxtx_q, &cmd_ptr->hdr.cmd_hdr.link);
(void) rex_set_sigs( &mc_tcb, MCC_Q_SIG );
} /* mccrxtx_cmd */
static void transcoder_video_engine_cb
(
video_status_type status, /* Status of callback */
void *client_data /* Client data from calling function */
)
{
boolean inbranch =FALSE;
venc_context_type *context;
context = (venc_context_type *) client_data;
if(!context || !venc_context)
{
MSG_ERROR("Raw engine not running, got a spurious callback",0,0,0);
return;
}
venc_context->videoStatus = status;
switch(status)
{
case VIDEO_SUCCESS:
{
switch((int32)client_data)
{
case VENC_FRAME_CALLBACK:
venc_context->frame_inuse[(venc_context->num_buffers +4)%VENC_FRAME_BUFFER_SIZE]
= FALSE;
inbranch = TRUE;
break;
default:
break;
}
if(inbranch)
break;
switch(venc_context->state)
{
case VIDEO_ENC_RAW_ENG_DSP_INIT:
/* Video Engine Initialization complete */
venc_context->state = VIDEO_ENC_RAW_ENG_INIT;
(void)rex_set_sigs((rex_tcb_type *)venc_context->tcb, VENC_SIG);
break;
case VIDEO_ENC_RAW_ENG_INIT:
/* Video Engine Start Complete */
venc_context->state = VIDEO_ENC_RAW_ENG_START;
(void)rex_set_sigs((rex_tcb_type *)venc_context->tcb, VENC_SIG);
break;
case VIDEO_ENC_RAW_ENG_START:
venc_context->state = VIDEO_ENC_RAW_ENG_ENCODE;
(void)rex_set_sigs((rex_tcb_type *)venc_context->tcb, VENC_SIG);
break;
case VIDEO_ENC_RAW_ENG_STOPPING:
case VIDEO_ENC_RAW_ENG_PAUSE:
case VIDEO_ENC_RAW_ENG_RESUME:
case VIDEO_ENC_RAW_ENG_ENCODE:
(void)rex_set_sigs((rex_tcb_type *)venc_context->tcb, VENC_SIG);
break;
case VIDEO_ENC_RAW_ENG_STOPPED:
if(venc_context->last_status == VIDEO_LIMIT_REACHED)
{
venc_context->callback(venc_context->last_status,
venc_context->frame_cb_data,
venc_context->client_data);
if(venc_context)
{
free(venc_context);
venc_context = NULL;
}
}
else
{
(void)rex_set_sigs((rex_tcb_type *)venc_context->tcb, VENC_SIG);
}
break;
default:
break;
}
}
break;
case VIDEO_FAILURE:
case VIDEO_LIMIT_NEAR:
case VIDEO_LIMIT_IMMINENT:
/* Error from Video Engine, will be called in VS task */
if (venc_context->callback != NULL)
{
venc_context->callback(status, venc_context->frame_cb_data,
venc_context->client_data);
}
(void)rex_set_sigs((rex_tcb_type *)venc_context->tcb, VENC_SIG);
break;
case VIDEO_LIMIT_REACHED:
/* Limit reached now we have to call video_eng_exit */
venc_context->last_status = status;
venc_context->state = VIDEO_ENC_RAW_ENG_STOPPED;
video_eng_exit(transcoder_video_engine_cb, (void*)venc_context);
break;
default:
break;
}
}
static void
video_async_task (dword parm)
{
rex_sigs_type sigs;
uint8 usedfilehandle;
(void) parm;
/*lint -e{716} infinite loop requires here */
while (1)
{
/* XXX: Replace 0xffffffff with the actual signal mask once we know
* what signal to use to process the async writes. 0xffffffff will work
* though.
*/
sigs = rex_wait (0xffffffff);
(void)rex_clr_sigs (rex_self (), 0xffffffff);
if ((sigs & TASK_OFFLINE_SIG) != 0)
task_offline ();
if ((sigs & TASK_STOP_SIG) != 0)
task_stop ();
if ((VIDEO_ASYNC_SIG & sigs) != 0)
{
efs_process_async_writes ();
}
if( ((sigs & VIDEO_ASYNC_SIG_FILECLOSE) != 0)||
((sigs & VIDEO_ASYNC_SIG_FILEUNLINK) != 0)
)
{
for(usedfilehandle = 0;usedfilehandle<MAX_FILE_CLOSE_SIZE;usedfilehandle++)
{
if(fs_handle_close[usedfilehandle])
{
(void)video_eng_file_fclose (fs_handle_close[usedfilehandle]);
fs_handle_close[usedfilehandle] = NULL;
}
}
for(usedfilehandle = 0;usedfilehandle<MAX_FILE_CLOSE_SIZE;usedfilehandle++)
{
if(filenames [usedfilehandle].used == 1)
{
efs_unlink (filenames [usedfilehandle].filename);
filenames [usedfilehandle].used = 0;
}
}
}
/* this should be before INIT if block in this loop
** Here we assume that all the previous call to the efs
** are synchronous
*/
if (sigs & VIDEO_ASYNC_SIG_REQ_COMPLETE)
{
(void)rex_set_sigs(video_async_client_tcb,
video_async_client_sig
);
video_async_client_tcb = NULL;
}
}
}
void mccsrch_set_srch_rpt_signal ( void )
{
/* Sets the MCC_Q_SIG for MC */
( void ) rex_set_sigs ( &mc_tcb, MCC_Q_SIG );
}
