/*-------------------------------------------------------------------*/
void* OMX_JpegEnc_Thread (void* pThreadData)
{
int status;
struct timeval tv;
int fdmax;
fd_set rfds;
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_COMMANDTYPE eCmd;
OMX_U32 nParam1;
sigset_t set;
prctl(PR_SET_NAME, (unsigned long) "OMX-JPGENC", 0, 0, 0);
OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pThreadData;
JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
#ifdef __PERF_INSTRUMENTATION__
pComponentPrivate->pPERFcomp = PERF_Create(PERF_FOURS("JPET"),
PERF_ModuleComponent |PERF_ModuleImageEncode);
#endif
/**Looking for highest number of file descriptor for pipes
inorder to put in select loop */
fdmax = pComponentPrivate->nCmdPipe[0];
if ( pComponentPrivate->free_outBuf_Q[0] > fdmax ) {
fdmax = pComponentPrivate->free_outBuf_Q[0];
}
if ( pComponentPrivate->filled_inpBuf_Q[0] > fdmax ) {
fdmax = pComponentPrivate->filled_inpBuf_Q[0];
}
OMX_TRACE2(pComponentPrivate->dbg, "fd max is %d\n",fdmax);
while ( 1 ) {
FD_ZERO (&rfds);
FD_SET (pComponentPrivate->nCmdPipe[0], &rfds);
if (pComponentPrivate->nCurState != OMX_StatePause) {
FD_SET (pComponentPrivate->free_outBuf_Q[0], &rfds);
FD_SET (pComponentPrivate->filled_inpBuf_Q[0], &rfds);
}
tv.tv_sec = 1;
tv.tv_usec = 0;
sigemptyset(&set) ;
sigaddset(&set,SIGALRM);
status = pselect (fdmax+1, &rfds, NULL, NULL, NULL,&set);
if ( 0 == status ) {
OMX_TRACE2(pComponentPrivate->dbg, "Component Thread Time Out!!!\n");
} else if ( -1 == status ) {
OMX_TRACE4(pComponentPrivate->dbg, "Error in Select\n");
pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle, pComponentPrivate->pHandle->pApplicationPrivate,
OMX_EventError, OMX_ErrorInsufficientResources, OMX_TI_ErrorSevere,
"Error from COmponent Thread in select");
eError = OMX_ErrorInsufficientResources;
} else {
if ( (FD_ISSET (pComponentPrivate->filled_inpBuf_Q[0], &rfds))
&& (pComponentPrivate->nCurState != OMX_StatePause) ) {
OMX_PRBUFFER2(pComponentPrivate->dbg, "filled_inpBuf_Q pipe is set\n");
eError = HandleJpegEncDataBuf_FromApp (pComponentPrivate);
if ( eError != OMX_ErrorNone ) {
OMX_PRBUFFER4(pComponentPrivate->dbg, "Error while processing free queue buffers\n");
pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle, pComponentPrivate->pHandle->pApplicationPrivate,
OMX_EventError, OMX_ErrorUndefined, OMX_TI_ErrorSevere,
"1-Error from Component Thread while processing free Q\n");
}
}
if ( FD_ISSET (pComponentPrivate->free_outBuf_Q[0], &rfds) ) {
OMX_PRBUFFER2(pComponentPrivate->dbg, "free_outBuf_Q has some buffers in Component Thread\n");
eError = HandleJpegEncFreeOutputBufferFromApp(pComponentPrivate);
if ( eError != OMX_ErrorNone ) {
OMX_PRBUFFER4(pComponentPrivate->dbg, "Error while processing free Q Buffers\n");
pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle, pComponentPrivate->pHandle->pApplicationPrivate,
OMX_EventError, OMX_ErrorUndefined, OMX_TI_ErrorSevere,
"3-Error from Component Thread while processing free Q\n");
}
}
if ( FD_ISSET (pComponentPrivate->nCmdPipe[0], &rfds) ) {
/* Do not accept any command when the component is stopping */
OMX_PRCOMM2(pComponentPrivate->dbg, "CMD pipe is set in Component Thread\n");
read (pComponentPrivate->nCmdPipe[0], &eCmd, sizeof (eCmd));
read (pComponentPrivate->nCmdDataPipe[0], &nParam1, sizeof (nParam1));
#ifdef __PERF_INSTRUMENTATION__
PERF_ReceivedCommand(pComponentPrivate->pPERFcomp,
eCmd, nParam1,
PERF_ModuleLLMM);
#endif
OMX_PRINT2(pComponentPrivate->dbg, "eCmd %d, nParam1 %d\n", (int)eCmd, (int)nParam1);
if ( eCmd == OMX_CommandStateSet ) {
OMX_PRINT2(pComponentPrivate->dbg, "processing OMX_CommandStateSet\n");
if ( (int)nParam1 != -1 ){
if(nParam1 == OMX_StateInvalid){
pComponentPrivate->nToState = OMX_StateInvalid;
}
eError = HandleJpegEncCommand (pComponentPrivate, nParam1);
if ( eError != OMX_ErrorNone ) {
OMX_PRINT4(pComponentPrivate->dbg, "Error returned by HandleJpegEncCommand\n");
pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle, pComponentPrivate->pHandle->pApplicationPrivate,
OMX_EventError, OMX_ErrorHardware, OMX_TI_ErrorSevere,
"Error returned by HandleJpegEncCommand\n");
}
}
else{
break;
}
}
else if ( eCmd == OMX_CommandPortDisable ) {
OMX_PRBUFFER2(pComponentPrivate->dbg, "Before Disable Port function Port %d\n",(int)nParam1);
eError = JpegEncDisablePort(pComponentPrivate, nParam1);
OMX_PRBUFFER2(pComponentPrivate->dbg, "After JPEG Encoder Sisable Port error = %d\n", eError);
if (eError != OMX_ErrorNone ) {
break;
}
}
else if ( eCmd == OMX_CommandPortEnable ) { /*TODO: Check errors*/
eError = JpegEncEnablePort(pComponentPrivate, nParam1);
if (eError != OMX_ErrorNone ) {
break;
}
}
else if ( eCmd == OMX_CustomCommandFatalError ) {
Jpeg_Enc_FatalErrorRecover(pComponentPrivate);
}
else if ( eCmd == OMX_CustomCommandStopThread ) {
/*eError = 10;*/
goto EXIT;
}
else if ( eCmd == OMX_CommandFlush ) {
OMX_PRBUFFER2(pComponentPrivate->dbg, "eCmd = OMX_CommandFlush\n");
eError = HandleJpegEncCommandFlush (pComponentPrivate, nParam1);
if (eError != OMX_ErrorNone) {
break;
}
}
if (pComponentPrivate->nCurState == OMX_StatePause)
continue;
}
}
}
OMX_PRINT1(pComponentPrivate->dbg, "Component Thread Exit while loop\n");
EXIT:
#ifdef __PERF_INSTRUMENTATION__
PERF_Done(pComponentPrivate->pPERFcomp);
#endif
OMX_PRINT1(pComponentPrivate->dbg, "Component Thread Exit while loop from EXIT label\n");
return(void*)eError; /*OMX_ErrorNone;*/
}
PERF_RT_Private *
PERF_RT_create(PERF_Private *perf, PERF_Config *config,
PERF_MODULETYPE eModule)
{
char *fOutFile = NULL;
FILE *fOut = NULL;
/* check if we support this component */
if (perf->ulID != PERF_FOURS("CAM_") && perf->ulID != PERF_FOURS("CAMT") &&
perf->ulID != PERF_FOURS("VP__") && perf->ulID != PERF_FOURS("VP_T") &&
perf->ulID != PERF_FOURS("VD__") && perf->ulID != PERF_FOURS("VD_T") &&
perf->ulID != PERF_FOURS("VE__") && perf->ulID != PERF_FOURS("VE_T"))
{
/* if we don't support this component, we don't create the real-time
interface */
return (NULL);
}
PERF_RT_Private *me =
perf->cip.pRT = malloc(sizeof(PERF_RT_Private));
if (me)
{
int succeed = 1;
/* we track steady state on the component thread only */
me->needSteadyState = (perf->ulID & 0xff) == 'T';
me->steadyState = 0;
/* allocate rate tracking structures */
me->maxDRate = MAX_RATES_TRACKED;
me->dRate = malloc(sizeof(PERF_RTdata_rate) * me->maxDRate);
succeed = succeed && me->dRate;
me->decoder = (perf->ulID == PERF_FOURS("VD__") || perf->ulID == PERF_FOURS("VD_T"));
me->encoder = (perf->ulID == PERF_FOURS("VE__") || perf->ulID == PERF_FOURS("VE_T"));
me->nDRate = 0;
/* allocate shot-to-shot tracking structures */
if (succeed && perf->ulID == PERF_FOURS("CAMT"))
{
me->dSTS = malloc(sizeof(PERF_RTdata_sts));
succeed = succeed && me->dSTS;
if (me->dSTS)
{
init_delay(&me->dSTS->dBurst, -1); /* no first timestamp yet */
init_delay(&me->dSTS->dABurst, 0);
init_delay(&me->dSTS->dBurst2, 0);
init_delay(&me->dSTS->dABurst2, 0);
init_delay(&me->dSTS->dSingle, -1); /* no first timestamp yet */
me->dSTS->size_max = me->dSTS->size_min = me->dSTS->capturing = 0;
}
}
else
{
me->dSTS = NULL;
}
/* allocate uptime tracking structures */
/* :NOTE: for now we restrict creations of uptime to steady state
only */
if (succeed && !uptime_started && me->needSteadyState &&
!(perf->uMode & PERF_Mode_Replay))
{
me->dUptime = malloc(sizeof(PERF_RTdata_uptime));
succeed = succeed && me->dUptime;
if (succeed)
{
uptime_started = 1;
me->dUptime->measuring = 0;
me->dUptime->last_idletime = me->dUptime->last_uptime = 0;
me->dUptime->start_idletime = me->dUptime->start_uptime = 0;
me->dUptime->success = 1;
me->dUptime->xx = me->dUptime->x = me->dUptime->n = 0;
TIME_GET(me->dUptime->last_reporting);
}
}
else
{
me->dUptime = NULL;
}
/* configuration */
me->summary = config->rt_summary != 0;
me->debug = config->rt_debug & 0x1FF;
me->detailed = (config->rt_detailed > 2) ? 2 : (int) config->rt_detailed;
me->granularity = (config->rt_granularity < 1) ? 1 :
(config->rt_granularity > MAX_GRANULARITY) ?
MAX_GRANULARITY : (long) config->rt_granularity;
me->granularity *= 1000000; /* convert to microsecs */
TIME_COPY(me->first_time, perf->time);
/* if we do not care about detailed statistics, only report significant
statistics for each component */
if (succeed && !me->detailed)
{
/* VP_T - display rate */
if (perf->ulID == PERF_FOURS("VP_T"))
{
me->only_moduleandflags = PERF_FlagSending | PERF_FlagFrame | PERF_ModuleHardware;
}
/* VD_T - decode rate */
else if (perf->ulID == PERF_FOURS("VD_T"))
{
me->only_moduleandflags = PERF_FlagSending | PERF_FlagFrame | PERF_ModuleLLMM;
}
/* VE_T - encode rate */
else if (perf->ulID == PERF_FOURS("VE_T"))
{
me->only_moduleandflags = PERF_FlagSending | PERF_FlagFrame | PERF_ModuleLLMM;
}
/* CAMT - capture rate */
else if (perf->ulID == PERF_FOURS("CAMT"))
{
me->only_moduleandflags = PERF_FlagReceived | PERF_FlagFrame | PERF_ModuleHardware;
}
/* otherwise, we don't care about rates */
else
{
free(me->dRate);
me->dRate = NULL;
me->maxDRate = 0;
}
}
/* set up fRt file pointers */
if (config->rt_file && succeed)
{
/* open log file unless STDOUT or STDERR is specified */
if (!strcasecmp(config->rt_file, "STDOUT")) fOut = stdout;
else if (!strcasecmp(config->rt_file, "STDERR")) fOut = stderr;
else
{
/* expand file name with PID and name */
fOutFile = (char *) malloc (strlen(config->rt_file) + 32);
if (fOutFile)
{
sprintf(fOutFile, "%s-%05lu-%08lx-%c%c%c%c.log",
config->rt_file, perf->ulPID, (unsigned long) perf,
PERF_FOUR_CHARS(perf->ulID));
fOut = fopen(fOutFile, "at");
/* free new file name */
free(fOutFile);
fOutFile = NULL;
}
/* if could not open output, set it to STDOUT */
if (!fOut) fOut = stderr;
}
me->fRt = fOut;
}
/* if we had allocation failures, free resources and return NULL */
if (succeed)
{
perf->uMode |= PERF_Mode_RealTime;
}
else
{
PERF_RT_done(perf);
me = NULL;
}
}
return(me);
}
