/* ========================================================================== */
static void readMsg(TIMM_OSAL_PTR pBuffer, TIMM_OSAL_U32 nNumBytes)
{
TIMM_OSAL_U32 actSizeRead = 0;
static systemMessage_t* tmpMsg = NULL;
if (!pBuffer){
SCREXEC_DBG_PRINT("Invalid return buffer supplied!\n");
return TIMM_OSAL_ERR_PARAMETER;
}
if(tmpMsg == NULL){
if (TIMM_OSAL_ERR_NONE != TIMM_OSAL_ReadFromPipe(STAND1_Script_Execution_PipeO, &tmpMsg, sizeof(systemMessage_t*), &actSizeRead, TIMM_OSAL_SUSPEND)) {
SCREXEC_DBG_PRINT("TIMM_OSAL_ReadFromPipe failed!\n");
return TIMM_OSAL_ERR_UNKNOWN;
}
}
if(actSizeRead != sizeof(systemMessage_t*)){
STAND1_DBG_PRINT("Requested %d bytes but read %d bytes\n", nNumBytes, actSizeRead);
return TIMM_OSAL_ERR_UNKNOWN;
}
if(tmpMsg == NULL){
SCREXEC_DBG_PRINT("Non-existent message!\n");
return TIMM_OSAL_ERR_UNKNOWN;
}
TIMM_OSAL_Memcpy(pBuffer, tmpMsg, sizeof(systemMessage_t));
if(tmpMsg->nPayloadSize == 0){
SCREXEC_DBG_PRINT("Successful message read!\nRead %08X", &tmpMsg);
TIMM_OSAL_Free(tmpMsg);
tmpMsg = NULL;
}else {
((systemMessage_t*)pBuffer)->pPayload = TIMM_OSAL_MallocExtn(tmpMsg->nPayloadSize, TIMM_OSAL_TRUE, 32, 0, NULL);
TIMM_OSAL_Memcpy(((systemMessage_t*)pBuffer)->pPayload, tmpMsg->pPayload, tmpMsg->nPayloadSize);
SCREXEC_DBG_PRINT("Successful message read!\nRead %08X", &tmpMsg);
TIMM_OSAL_Free(tmpMsg->pPayload);
TIMM_OSAL_Free(tmpMsg);
tmpMsg = NULL;
}
return TIMM_OSAL_ERR_NONE;
}
TIMM_OSAL_ERRORTYPE CCommunicationChannelImplementation::MsgReceive(TIMM_OSAL_PTR* pCurMessage)
{
TIMM_OSAL_ERRORTYPE error = TIMM_OSAL_ERR_NONE;
systemMessage_t* message;
TIMM_OSAL_U32 nMessageSize = 0;
// Allocate space for message header
message = (systemMessage_t*)TIMM_OSAL_MallocExtn(DEFAULT_MESSAGE_SIZE, TIMM_OSAL_TRUE, 32,
TIMMOSAL_MEM_SEGMENT_EXT, NULL);
//printf("internalMsgRecvThread: Allocate message\n");
if (!message)
{
printf("Cant allocate %d bytes form message header\n", DEFAULT_MESSAGE_SIZE);
return TIMM_OSAL_ERR_ALLOC;
}
*(systemMessage_t **)pCurMessage = message;
message->pPayload = NULL;
//TIMM_OSAL_ReadFromPipe doesn't support timeout
// printf("internalMsgRecvThread: Read from Pipe!\n");
error = TIMM_OSAL_ReadFromPipe(internalMsgPipe, message, DEFAULT_MESSAGE_SIZE, &nMessageSize,
TIMM_OSAL_SUSPEND);//inifinite timeout
if (TIMM_OSAL_ERR_NONE != error)
{
TIMM_OSAL_Free(message);
message = NULL;
printf("Can't read from message pipe\n");
return error;
} else if (nMessageSize < sizeof(systemMessage_t))
{
TIMM_OSAL_Free(message);
message = NULL;
printf("Read data is less than message header size\n");
return TIMM_OSAL_ERR_MSG_SIZE_MISMATCH;
}
return TIMM_OSAL_ERR_NONE;
}
/*========================================================*/
void Camera_processfbd(void *threadsArg)
{
OMX_BUFFERHEADERTYPE *pBuffHeader = NULL;
OMX_ERRORTYPE err = OMX_ErrorNone;
TIMM_OSAL_U32 uRequestedEvents, pRetrievedEvents;
struct port_param *pPortParam;
int buffer_index, buffer_to_q;
unsigned int numRemainingIn = 0;
int ii;
unsigned int actualSize = 0;
pthread_t thread_id;
int policy;
int rc = 0;
struct sched_param param;
thread_id = pthread_self();
dprintf(0, "New Thread Created\n");
rc = pthread_getschedparam(thread_id, &policy, ¶m);
if (rc != 0)
dprintf(0, "<Thread> 1 error %d\n", rc);
printf("<Thread> %d %d\n", policy, param.sched_priority);
param.sched_priority = 10;
rc = pthread_setschedparam(thread_id, SCHED_RR /*policy */ , ¶m);
if (rc != 0)
dprintf(0, "<Thread> 2 error %d\n", rc);
rc = pthread_getschedparam(thread_id, &policy, ¶m);
if (rc != 0)
dprintf(0, "<Thread> 3 error %d\n", rc);
dprintf(0, "<Thread> %d %d %d %d\n", policy, param.sched_priority,
sched_get_priority_min(policy), sched_get_priority_max(policy));
while (OMX_ErrorNone == err)
{
uRequestedEvents = EVENT_CAMERA_FBD;
dprintf(3, " going to wait for event retreive in thread \n");
err = TIMM_OSAL_EventRetrieve(myEventIn, uRequestedEvents,
TIMM_OSAL_EVENT_OR_CONSUME, &pRetrievedEvents,
TIMM_OSAL_SUSPEND);
if (TIMM_OSAL_ERR_NONE != err)
{
dprintf(0, "error = %d pRetrievedEvents\n", err,
&pRetrievedEvents);
TIMM_OSAL_Error("Error in Retrieving event!");
err = OMX_ErrorUndefined;
}
/* Read the number of buffers available in pipe */
TIMM_OSAL_GetPipeReadyMessageCount(pContext->FBD_pipe,
(void *)&numRemainingIn);
while (numRemainingIn)
{
err = TIMM_OSAL_ReadFromPipe(pContext->FBD_pipe,
&pBuffHeader, sizeof(pBuffHeader), &actualSize,
TIMM_OSAL_SUSPEND);
if (err != TIMM_OSAL_ERR_NONE)
{
printf("\n<Thread>Read from FBD_pipe\
unsuccessful, going back to wait for event\n");
break;
}
dprintf(2, "\n ReadFromPipe successfully returned\n");
buffer_index = (int)pBuffHeader->pAppPrivate;
dprintf(2, "\n buffer_index = %d\n", buffer_index);
pPortParam =
&(pContext->sPortParam[pBuffHeader->
nOutputPortIndex]);
dprintf(3, "FillBufferDone for Port = %d\n",
(int)pBuffHeader->nOutputPortIndex);
dprintf(2, "buffer index = %d remaing messages=%d\n",
(int)pBuffHeader->pAppPrivate, numRemainingIn);
dprintf(2, "Filled Length is = %d ",
(int)pBuffHeader->nFilledLen);
if (pBuffHeader->nOutputPortIndex ==
OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW)
{
dprintf(3, "Preview port frame Done number =\
%d\n", (int)pPortParam->nCapFrame);
pPortParam->nCapFrame++;
dprintf(3, "\n Before SendbufferToDss() \n");
buffer_to_q = SendbufferToDss(buffer_index,
vid1_fd);
if (buffer_to_q != 0xFF)
{
omx_fillthisbuffer(buffer_to_q,
OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW);
}
}
dprintf(2, "\n FillBufferDone \n");
TIMM_OSAL_GetPipeReadyMessageCount(pContext->FBD_pipe,
(void *)&numRemainingIn);
dprintf(2, " buffer index = %d remaing messages=%d\n",
(int)pBuffHeader->pAppPrivate, numRemainingIn);
}
