/*
* Work loop for threads. Should be passed into the pthread_create() method.
*
*/
static void *thread_do_work(void *arg)
{
struct tpool *pool = (struct tpool*)arg;
struct pool_task *task = NULL;
int i;
// sigset_t sig_set;
// sigemptyset(&sig_set);
// sigaddset(&sig_set, SIGINT);
// sigfillset(&sig_set);
// pthread_sigmask(SIG_BLOCK, &sig_set, NULL);
while(!pool->quit) {
tsem_wait(&pool->sem);
// lock the queue before remove thing from it
pthread_mutex_lock(&pool->queue_mutex);
// check the highest priority task queue first
// then the lower
// final the lowest
for(i = 0; i < PRIORITY_LEVEL; i++) {
if(!(pool->task_queue[i].next == &pool->task_queue[i])) {
task = pool->task_queue[i].next;
list_remove(task);
break;
}
}
pthread_mutex_unlock(&pool->queue_mutex);
assert(task);
if(!task)
continue;
// TODO begin to do the work
assert(task->function);
// printf("in function\n");
pthread_cleanup_push(mem_cleanup, (void*)task);
task->function(task->argument);
pthread_cleanup_pop(0);
// printf("out function\n");
free(task);
// reset the task pointer
task = NULL;
}
pthread_exit(NULL);
return(NULL);
}
static void
update_status (int i,
int eating)
{
static int status[5] = { 0, };
int idx;
status[i] = eating;
tsem_wait (printing);
int sum = 0;
for (idx = 0; idx < 5; idx++)
{
fprintf (stdout, "%3s ", status[idx] ? "EAT" : "...");
sum += status[idx];
}
fprintf (stdout, "\n");
assert(sum > 0); // 항상 한명 이상이 식사중인지 체크
tsem_signal (printing);
}
/** This is the central function for component processing. It
* is executed in a separate thread, is synchronized with
* semaphores at each port, those are released each time a new buffer
* is available on the given port.
*/
void* omx_base_sink_BufferMgmtFunction (void* param) {
OMX_COMPONENTTYPE* openmaxStandComp = (OMX_COMPONENTTYPE*)param;
omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
omx_base_sink_PrivateType* omx_base_sink_Private = (omx_base_sink_PrivateType*)omx_base_component_Private;
omx_base_PortType *pInPort = (omx_base_PortType *)omx_base_sink_Private->ports[OMX_BASE_SINK_INPUTPORT_INDEX];
tsem_t* pInputSem = pInPort->pBufferSem;
queue_t* pInputQueue = pInPort->pBufferQueue;
OMX_BUFFERHEADERTYPE* pInputBuffer = NULL;
OMX_COMPONENTTYPE* target_component;
OMX_BOOL isInputBufferNeeded = OMX_TRUE;
int inBufExchanged = 0;
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s \n", __func__);
while(omx_base_component_Private->state == OMX_StateIdle || omx_base_component_Private->state == OMX_StateExecuting || omx_base_component_Private->state == OMX_StatePause ||
omx_base_component_Private->transientState == OMX_TransStateLoadedToIdle){
/*Wait till the ports are being flushed*/
pthread_mutex_lock(&omx_base_sink_Private->flush_mutex);
while( PORT_IS_BEING_FLUSHED(pInPort)) {
pthread_mutex_unlock(&omx_base_sink_Private->flush_mutex);
if(isInputBufferNeeded==OMX_FALSE) {
pInPort->ReturnBufferFunction(pInPort,pInputBuffer);
inBufExchanged--;
pInputBuffer=NULL;
isInputBufferNeeded=OMX_TRUE;
DEBUG(DEB_LEV_FULL_SEQ, "Ports are flushing,so returning input buffer\n");
}
DEBUG(DEB_LEV_FULL_SEQ, "In %s signalling flush all condition \n", __func__);
tsem_up(omx_base_sink_Private->flush_all_condition);
tsem_down(omx_base_sink_Private->flush_condition);
pthread_mutex_lock(&omx_base_sink_Private->flush_mutex);
}
pthread_mutex_unlock(&omx_base_sink_Private->flush_mutex);
/*No buffer to process. So wait here*/
if((pInputSem->semval==0 && isInputBufferNeeded==OMX_TRUE ) &&
(omx_base_sink_Private->state != OMX_StateLoaded && omx_base_sink_Private->state != OMX_StateInvalid)) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "Waiting for input buffer \n");
tsem_down(omx_base_sink_Private->bMgmtSem);
}
if(omx_base_sink_Private->state == OMX_StateLoaded || omx_base_sink_Private->state == OMX_StateInvalid) {
DEBUG(DEB_LEV_FULL_SEQ, "In %s Buffer Management Thread is exiting\n",__func__);
break;
}
DEBUG(DEB_LEV_SIMPLE_SEQ, "Waiting for input buffer semval=%d \n",pInputSem->semval);
if(pInputSem->semval>0 && isInputBufferNeeded==OMX_TRUE ) {
tsem_down(pInputSem);
if(pInputQueue->nelem>0){
inBufExchanged++;
isInputBufferNeeded=OMX_FALSE;
pInputBuffer = dequeue(pInputQueue);
if(pInputBuffer == NULL){
DEBUG(DEB_LEV_ERR, "Had NULL input buffer!!\n");
break;
}
}
}
if(isInputBufferNeeded==OMX_FALSE) {
if(pInputBuffer->nFlags==OMX_BUFFERFLAG_EOS) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "Detected EOS flags in input buffer\n");
(*(omx_base_component_Private->callbacks->EventHandler))
(openmaxStandComp,
omx_base_component_Private->callbackData,
OMX_EventBufferFlag, /* The command was completed */
0, /* The commands was a OMX_CommandStateSet */
pInputBuffer->nFlags, /* The state has been changed in message->messageParam2 */
NULL);
pInputBuffer->nFlags=0;
}
target_component=(OMX_COMPONENTTYPE*)pInputBuffer->hMarkTargetComponent;
if(target_component==(OMX_COMPONENTTYPE *)openmaxStandComp) {
/*Clear the mark and generate an event*/
(*(omx_base_component_Private->callbacks->EventHandler))
(openmaxStandComp,
omx_base_component_Private->callbackData,
OMX_EventMark, /* The command was completed */
1, /* The commands was a OMX_CommandStateSet */
0, /* The state has been changed in message->messageParam2 */
pInputBuffer->pMarkData);
} else if(pInputBuffer->hMarkTargetComponent!=NULL){
/*If this is not the target component then pass the mark*/
DEBUG(DEB_LEV_FULL_SEQ, "Can't Pass Mark. This is a Sink!!\n");
}
if (omx_base_sink_Private->BufferMgmtCallback && pInputBuffer->nFilledLen > 0) {
(*(omx_base_sink_Private->BufferMgmtCallback))(openmaxStandComp, pInputBuffer);
}
else {
/*If no buffer management call back the explicitly consume input buffer*/
pInputBuffer->nFilledLen = 0;
}
/*Input Buffer has been completely consumed. So, get new input buffer*/
if(omx_base_sink_Private->state==OMX_StatePause && !PORT_IS_BEING_FLUSHED(pInPort)) {
/*Waiting at paused state*/
tsem_wait(omx_base_sink_Private->bStateSem);
}
/*Input Buffer has been completely consumed. So, return input buffer*/
if(pInputBuffer->nFilledLen==0) {
pInPort->ReturnBufferFunction(pInPort,pInputBuffer);
inBufExchanged--;
pInputBuffer=NULL;
isInputBufferNeeded = OMX_TRUE;
}
}
}
DEBUG(DEB_LEV_SIMPLE_SEQ,"Exiting Buffer Management Thread\n");
return NULL;
}
/** This is the central function for component processing. It
* is executed in a separate thread, is synchronized with
* semaphores at each port, those are released each time a new buffer
* is available on the given port.
*/
void* omx_base_source_BufferMgmtFunction (void* param) {
OMX_COMPONENTTYPE* openmaxStandComp = (OMX_COMPONENTTYPE*)param;
omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
omx_base_source_PrivateType* omx_base_source_Private = (omx_base_source_PrivateType*)omx_base_component_Private;
omx_base_PortType *pOutPort = (omx_base_PortType *)omx_base_source_Private->ports[OMX_BASE_SOURCE_OUTPUTPORT_INDEX];
tsem_t* pOutputSem = pOutPort->pBufferSem;
queue_t* pOutputQueue = pOutPort->pBufferQueue;
OMX_BUFFERHEADERTYPE* pOutputBuffer = NULL;
OMX_COMPONENTTYPE* target_component;
OMX_BOOL isOutputBufferNeeded = OMX_TRUE;
int outBufExchanged = 0;
omx_base_source_Private->bellagioThreads->nThreadBufferMngtID = (long int)syscall(__NR_gettid);
DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s the thread ID is %i\n", __func__, (int)omx_base_source_Private->bellagioThreads->nThreadBufferMngtID);
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s \n", __func__);
while(omx_base_component_Private->state == OMX_StateIdle || omx_base_component_Private->state == OMX_StateExecuting ||
omx_base_component_Private->state == OMX_StatePause || omx_base_component_Private->transientState == OMX_TransStateLoadedToIdle){
/*Wait till the ports are being flushed*/
pthread_mutex_lock(&omx_base_source_Private->flush_mutex);
while( PORT_IS_BEING_FLUSHED(pOutPort)) {
pthread_mutex_unlock(&omx_base_source_Private->flush_mutex);
if(isOutputBufferNeeded == OMX_FALSE) {
pOutPort->ReturnBufferFunction(pOutPort, pOutputBuffer);
outBufExchanged--;
pOutputBuffer = NULL;
isOutputBufferNeeded = OMX_TRUE;
DEBUG(DEB_LEV_FULL_SEQ, "Ports are flushing,so returning output buffer\n");
}
DEBUG(DEB_LEV_FULL_SEQ, "In %s signalling flush all condition \n", __func__);
tsem_up(omx_base_source_Private->flush_all_condition);
tsem_down(omx_base_source_Private->flush_condition);
pthread_mutex_lock(&omx_base_source_Private->flush_mutex);
}
pthread_mutex_unlock(&omx_base_source_Private->flush_mutex);
/*No buffer to process. So wait here*/
if((isOutputBufferNeeded==OMX_TRUE && pOutputSem->semval==0) &&
(omx_base_source_Private->state != OMX_StateLoaded && omx_base_source_Private->state != OMX_StateInvalid)) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "Waiting for output buffer \n");
tsem_down(omx_base_source_Private->bMgmtSem);
}
if(omx_base_source_Private->state == OMX_StateLoaded || omx_base_source_Private->state == OMX_StateInvalid) {
DEBUG(DEB_LEV_FULL_SEQ, "In %s Buffer Management Thread is exiting\n",__func__);
break;
}
DEBUG(DEB_LEV_SIMPLE_SEQ, "Waiting for output buffer semval=%d \n",pOutputSem->semval);
if(pOutputSem->semval > 0 && isOutputBufferNeeded == OMX_TRUE ) {
tsem_down(pOutputSem);
if(pOutputQueue->nelem>0){
outBufExchanged++;
isOutputBufferNeeded = OMX_FALSE;
pOutputBuffer = dequeue(pOutputQueue);
if(pOutputBuffer == NULL){
DEBUG(DEB_LEV_ERR, "In %s Had NULL output buffer!!\n",__func__);
break;
}
}
}
if(isOutputBufferNeeded == OMX_FALSE) {
if((pOutputBuffer->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
pOutputBuffer->nFlags = 0;
}
if(omx_base_source_Private->pMark.hMarkTargetComponent != NULL){
pOutputBuffer->hMarkTargetComponent = omx_base_source_Private->pMark.hMarkTargetComponent;
pOutputBuffer->pMarkData = omx_base_source_Private->pMark.pMarkData;
omx_base_source_Private->pMark.hMarkTargetComponent = NULL;
omx_base_source_Private->pMark.pMarkData = NULL;
}
target_component = (OMX_COMPONENTTYPE*)pOutputBuffer->hMarkTargetComponent;
if(target_component == (OMX_COMPONENTTYPE *)openmaxStandComp) {
/*Clear the mark and generate an event*/
(*(omx_base_component_Private->callbacks->EventHandler))
(openmaxStandComp,
omx_base_component_Private->callbackData,
OMX_EventMark, /* The command was completed */
1, /* The commands was a OMX_CommandStateSet */
0, /* The state has been changed in message->messageParam2 */
pOutputBuffer->pMarkData);
} else if(pOutputBuffer->hMarkTargetComponent != NULL) {
/*If this is not the target component then pass the mark*/
DEBUG(DEB_LEV_FULL_SEQ, "Pass Mark. This is a Source!!\n");
}
if(omx_base_source_Private->state == OMX_StateExecuting) {
if (omx_base_source_Private->BufferMgmtCallback && pOutputBuffer->nFilledLen == 0) {
(*(omx_base_source_Private->BufferMgmtCallback))(openmaxStandComp, pOutputBuffer);
} else {
/*It no buffer management call back then don't produce any output buffer*/
pOutputBuffer->nFilledLen = 0;
}
} else {
DEBUG(DEB_LEV_ERR, "In %s Received Buffer in non-Executing State(%x)\n", __func__, (int)omx_base_source_Private->state);
}
if(omx_base_source_Private->state == OMX_StatePause && !PORT_IS_BEING_FLUSHED(pOutPort)) {
/*Waiting at paused state*/
tsem_wait(omx_base_source_Private->bStateSem);
}
if((pOutputBuffer->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "Detected EOS flags in output buffer\n");
(*(omx_base_component_Private->callbacks->EventHandler))
(openmaxStandComp,
omx_base_component_Private->callbackData,
OMX_EventBufferFlag, /* The command was completed */
0, /* The commands was a OMX_CommandStateSet */
pOutputBuffer->nFlags, /* The state has been changed in message->messageParam2 */
NULL);
//pOutputBuffer->nFlags = 0;
omx_base_source_Private->bIsEOSReached = OMX_TRUE;
}
/*Output Buffer has been produced or EOS. So, return output buffer and get new buffer*/
if((pOutputBuffer->nFilledLen != 0) || ((pOutputBuffer->nFlags & OMX_BUFFERFLAG_EOS) ==OMX_BUFFERFLAG_EOS) || (omx_base_source_Private->bIsEOSReached == OMX_TRUE)) {
if((pOutputBuffer->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)
DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s nFlags=%x Name=%s \n", __func__, (int)pOutputBuffer->nFlags, omx_base_source_Private->name);
pOutPort->ReturnBufferFunction(pOutPort, pOutputBuffer);
outBufExchanged--;
pOutputBuffer = NULL;
isOutputBufferNeeded = OMX_TRUE;
}
}
}
DEBUG(DEB_LEV_SIMPLE_SEQ, "Exiting Buffer Management Thread\n");
return NULL;
}
void* omx_base_source_twoport_BufferMgmtFunction (void* param) {
OMX_COMPONENTTYPE* openmaxStandComp = (OMX_COMPONENTTYPE*)param;
omx_base_component_PrivateType* omx_base_component_Private=(omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
omx_base_source_PrivateType* omx_base_source_Private = (omx_base_source_PrivateType*)omx_base_component_Private;
omx_base_PortType *pOutPort[2];
tsem_t* pOutputSem[2];
queue_t* pOutputQueue[2];
OMX_BUFFERHEADERTYPE* pOutputBuffer[2];
OMX_COMPONENTTYPE* target_component;
OMX_BOOL isOutputBufferNeeded[2];
int i,outBufExchanged[2];
pOutPort[0]=(omx_base_PortType *)omx_base_source_Private->ports[OMX_BASE_SOURCE_OUTPUTPORT_INDEX];
pOutPort[1]=(omx_base_PortType *)omx_base_source_Private->ports[OMX_BASE_SOURCE_OUTPUTPORT_INDEX_1];
pOutputSem[0] = pOutPort[0]->pBufferSem;
pOutputSem[1] = pOutPort[1]->pBufferSem;
pOutputQueue[0] = pOutPort[0]->pBufferQueue;
pOutputQueue[1] = pOutPort[1]->pBufferQueue;
pOutputBuffer[1]= pOutputBuffer[0]=NULL;
isOutputBufferNeeded[0]=isOutputBufferNeeded[1]=OMX_TRUE;
outBufExchanged[0]=outBufExchanged[1]=0;
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
while(omx_base_source_Private->state == OMX_StateIdle || omx_base_source_Private->state == OMX_StateExecuting || omx_base_source_Private->state == OMX_StatePause ||
omx_base_source_Private->transientState == OMX_TransStateLoadedToIdle){
/*Wait till the ports are being flushed*/
pthread_mutex_lock(&omx_base_source_Private->flush_mutex);
while( PORT_IS_BEING_FLUSHED(pOutPort[0]) ||
PORT_IS_BEING_FLUSHED(pOutPort[1])) {
pthread_mutex_unlock(&omx_base_source_Private->flush_mutex);
DEBUG(DEB_LEV_FULL_SEQ, "In %s 1 signalling flush all cond iE=%d,iF=%d,oE=%d,oF=%d iSemVal=%d,oSemval=%d\n",
__func__,outBufExchanged[0],isOutputBufferNeeded[0],outBufExchanged[1],isOutputBufferNeeded[1],pOutputSem[0]->semval,pOutputSem[1]->semval);
if(isOutputBufferNeeded[1]==OMX_FALSE && PORT_IS_BEING_FLUSHED(pOutPort[1])) {
pOutPort[1]->ReturnBufferFunction(pOutPort[1],pOutputBuffer[1]);
outBufExchanged[1]--;
pOutputBuffer[1]=NULL;
isOutputBufferNeeded[1]=OMX_TRUE;
DEBUG(DEB_LEV_FULL_SEQ, "Ports are flushing,so returning output 1 buffer\n");
}
if(isOutputBufferNeeded[0]==OMX_FALSE && PORT_IS_BEING_FLUSHED(pOutPort[0])) {
pOutPort[0]->ReturnBufferFunction(pOutPort[0],pOutputBuffer[0]);
outBufExchanged[0]--;
pOutputBuffer[0]=NULL;
isOutputBufferNeeded[0]=OMX_TRUE;
DEBUG(DEB_LEV_FULL_SEQ, "Ports are flushing,so returning output 0 buffer\n");
}
DEBUG(DEB_LEV_FULL_SEQ, "In %s 2 signalling flush all cond iE=%d,iF=%d,oE=%d,oF=%d iSemVal=%d,oSemval=%d\n",
__func__,outBufExchanged[0],isOutputBufferNeeded[0],outBufExchanged[1],isOutputBufferNeeded[1],pOutputSem[0]->semval,pOutputSem[1]->semval);
tsem_up(omx_base_source_Private->flush_all_condition);
tsem_down(omx_base_source_Private->flush_condition);
pthread_mutex_lock(&omx_base_source_Private->flush_mutex);
}
pthread_mutex_unlock(&omx_base_source_Private->flush_mutex);
/*No buffer to process. So wait here*/
if((isOutputBufferNeeded[0]==OMX_TRUE && pOutputSem[0]->semval==0) &&
(omx_base_source_Private->state != OMX_StateLoaded && omx_base_source_Private->state != OMX_StateInvalid)) {
//Signalled from EmptyThisBuffer or FillThisBuffer or some thing else
DEBUG(DEB_LEV_FULL_SEQ, "Waiting for next output buffer 0\n");
tsem_down(omx_base_source_Private->bMgmtSem);
}
if(omx_base_source_Private->state == OMX_StateLoaded || omx_base_source_Private->state == OMX_StateInvalid) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Buffer Management Thread is exiting\n",__func__);
break;
}
if((isOutputBufferNeeded[1]==OMX_TRUE && pOutputSem[1]->semval==0) &&
(omx_base_source_Private->state != OMX_StateLoaded && omx_base_source_Private->state != OMX_StateInvalid) &&
!(PORT_IS_BEING_FLUSHED(pOutPort[0]) || PORT_IS_BEING_FLUSHED(pOutPort[1]))) {
//Signalled from EmptyThisBuffer or FillThisBuffer or some thing else
DEBUG(DEB_LEV_FULL_SEQ, "Waiting for next output buffer 1\n");
tsem_down(omx_base_source_Private->bMgmtSem);
}
if(omx_base_source_Private->state == OMX_StateLoaded || omx_base_source_Private->state == OMX_StateInvalid) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Buffer Management Thread is exiting\n",__func__);
break;
}
DEBUG(DEB_LEV_SIMPLE_SEQ, "Waiting for output buffer 0 semval=%d \n",pOutputSem[0]->semval);
if(pOutputSem[0]->semval>0 && isOutputBufferNeeded[0]==OMX_TRUE ) {
tsem_down(pOutputSem[0]);
if(pOutputQueue[0]->nelem>0){
outBufExchanged[0]++;
isOutputBufferNeeded[0]=OMX_FALSE;
pOutputBuffer[0] = dequeue(pOutputQueue[0]);
if(pOutputBuffer[0] == NULL){
DEBUG(DEB_LEV_ERR, "Had NULL output buffer!!\n");
break;
}
}
}
/*When we have input buffer to process then get one output buffer*/
if(pOutputSem[1]->semval>0 && isOutputBufferNeeded[1]==OMX_TRUE) {
tsem_down(pOutputSem[1]);
if(pOutputQueue[1]->nelem>0){
outBufExchanged[1]++;
isOutputBufferNeeded[1]=OMX_FALSE;
pOutputBuffer[1] = dequeue(pOutputQueue[1]);
if(pOutputBuffer[1] == NULL){
DEBUG(DEB_LEV_ERR, "Had NULL output buffer!! op is=%d,iq=%d\n",pOutputSem[1]->semval,pOutputQueue[1]->nelem);
break;
}
}
}
for(i=0;i < (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts -1);i++) {
if(omx_base_source_Private->ports[i]->sPortParam.eDomain!=OMX_PortDomainOther){ /* clock ports are not to be processed */
/*Process Output buffer of Port i */
if(isOutputBufferNeeded[i]==OMX_FALSE) {
/*Pass the Mark to all outgoing buffers*/
if(omx_base_source_Private->pMark.hMarkTargetComponent != NULL){
pOutputBuffer[i]->hMarkTargetComponent = omx_base_source_Private->pMark.hMarkTargetComponent;
pOutputBuffer[i]->pMarkData = omx_base_source_Private->pMark.pMarkData;
}
target_component=(OMX_COMPONENTTYPE*)pOutputBuffer[i]->hMarkTargetComponent;
if(target_component==(OMX_COMPONENTTYPE *)openmaxStandComp) {
/*Clear the mark and generate an event*/
(*(omx_base_source_Private->callbacks->EventHandler))
(openmaxStandComp,
omx_base_source_Private->callbackData,
OMX_EventMark, /* The command was completed */
1, /* The commands was a OMX_CommandStateSet */
i, /* The state has been changed in message->messageParam2 */
pOutputBuffer[i]->pMarkData);
} else if(pOutputBuffer[i]->hMarkTargetComponent!=NULL){
/*If this is not the target component then pass the mark*/
DEBUG(DEB_LEV_FULL_SEQ, "Pass Mark. This is a Source!!\n");
}
if(omx_base_source_Private->state == OMX_StateExecuting) {
if (omx_base_source_Private->BufferMgmtCallback && pOutputBuffer[i]->nFilledLen == 0) {
(*(omx_base_source_Private->BufferMgmtCallback))(openmaxStandComp, pOutputBuffer[i]);
} else {
/*If no buffer management call back then don't produce any output buffer*/
pOutputBuffer[i]->nFilledLen = 0;
}
} else {
DEBUG(DEB_LEV_ERR, "In %s Received Buffer in non-Executing State(%x)\n", __func__, (int)omx_base_source_Private->state);
}
if((pOutputBuffer[i]->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS && pOutputBuffer[i]->nFilledLen==0) {
DEBUG(DEB_LEV_FULL_SEQ, "Detected EOS flags in input buffer filled len=%d\n", (int)pOutputBuffer[i]->nFilledLen);
(*(omx_base_source_Private->callbacks->EventHandler))
(openmaxStandComp,
omx_base_source_Private->callbackData,
OMX_EventBufferFlag, /* The command was completed */
i, /* The commands was a OMX_CommandStateSet */
pOutputBuffer[i]->nFlags, /* The state has been changed in message->messageParam2 */
NULL);
}
if(omx_base_source_Private->state==OMX_StatePause && !(PORT_IS_BEING_FLUSHED(pOutPort[0]) || PORT_IS_BEING_FLUSHED(pOutPort[1]))) {
/*Waiting at paused state*/
tsem_wait(omx_base_component_Private->bStateSem);
}
/*Output Buffer has been produced or EOS. So, return output buffer and get new buffer*/
if(pOutputBuffer[i]->nFilledLen!=0 || (pOutputBuffer[i]->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS){
pOutPort[i]->ReturnBufferFunction(pOutPort[i],pOutputBuffer[i]);
outBufExchanged[i]--;
pOutputBuffer[i]=NULL;
isOutputBufferNeeded[i]=OMX_TRUE;
}
}
}
}
/*Clear the Mark*/
if(omx_base_source_Private->pMark.hMarkTargetComponent != NULL){
omx_base_source_Private->pMark.hMarkTargetComponent = NULL;
omx_base_source_Private->pMark.pMarkData = NULL;
}
}
DEBUG(DEB_LEV_SIMPLE_SEQ,"Exiting Buffer Management Thread\n");
return NULL;
}
/** This is the central function for component processing. It
* is executed in a separate thread, is synchronized with
* semaphores at each port, those are released each time a new buffer
* is available on the given port.
*/
void* omx_base_filter_BufferMgmtFunction (void* param) {
OMX_COMPONENTTYPE* openmaxStandComp = (OMX_COMPONENTTYPE*)param;
omx_base_filter_PrivateType* omx_base_filter_Private = (omx_base_filter_PrivateType*)openmaxStandComp->pComponentPrivate;
omx_base_PortType *pInPort=(omx_base_PortType *)omx_base_filter_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
omx_base_PortType *pOutPort=(omx_base_PortType *)omx_base_filter_Private->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
tsem_t* pInputSem = pInPort->pBufferSem;
tsem_t* pOutputSem = pOutPort->pBufferSem;
queue_t* pInputQueue = pInPort->pBufferQueue;
queue_t* pOutputQueue = pOutPort->pBufferQueue;
OMX_BUFFERHEADERTYPE* pOutputBuffer=NULL;
OMX_BUFFERHEADERTYPE* pInputBuffer=NULL;
OMX_BOOL isInputBufferNeeded=OMX_TRUE,isOutputBufferNeeded=OMX_TRUE;
int inBufExchanged=0,outBufExchanged=0;
omx_base_filter_Private->bellagioThreads->nThreadBufferMngtID = (long int)syscall(__NR_gettid);
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s of component %p\n", __func__, openmaxStandComp);
DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s the thread ID is %i\n", __func__, (int)omx_base_filter_Private->bellagioThreads->nThreadBufferMngtID);
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
/* checks if the component is in a state able to receive buffers */
while(omx_base_filter_Private->state == OMX_StateIdle || omx_base_filter_Private->state == OMX_StateExecuting || omx_base_filter_Private->state == OMX_StatePause ||
omx_base_filter_Private->transientState == OMX_TransStateLoadedToIdle){
/*Wait till the ports are being flushed*/
pthread_mutex_lock(&omx_base_filter_Private->flush_mutex);
while( PORT_IS_BEING_FLUSHED(pInPort) ||
PORT_IS_BEING_FLUSHED(pOutPort)) {
pthread_mutex_unlock(&omx_base_filter_Private->flush_mutex);
DEBUG(DEB_LEV_FULL_SEQ, "In %s 1 signaling flush all cond iE=%d,iF=%d,oE=%d,oF=%d iSemVal=%d,oSemval=%d\n",
__func__,inBufExchanged,isInputBufferNeeded,outBufExchanged,isOutputBufferNeeded,pInputSem->semval,pOutputSem->semval);
if(isOutputBufferNeeded==OMX_FALSE && PORT_IS_BEING_FLUSHED(pOutPort)) {
pOutPort->ReturnBufferFunction(pOutPort,pOutputBuffer);
outBufExchanged--;
pOutputBuffer=NULL;
isOutputBufferNeeded=OMX_TRUE;
DEBUG(DEB_LEV_FULL_SEQ, "Ports are flushing,so returning output buffer\n");
}
if(isInputBufferNeeded==OMX_FALSE && PORT_IS_BEING_FLUSHED(pInPort)) {
pInPort->ReturnBufferFunction(pInPort,pInputBuffer);
inBufExchanged--;
pInputBuffer=NULL;
isInputBufferNeeded=OMX_TRUE;
DEBUG(DEB_LEV_FULL_SEQ, "Ports are flushing,so returning input buffer\n");
}
DEBUG(DEB_LEV_FULL_SEQ, "In %s 2 signaling flush all cond iE=%d,iF=%d,oE=%d,oF=%d iSemVal=%d,oSemval=%d\n",
__func__,inBufExchanged,isInputBufferNeeded,outBufExchanged,isOutputBufferNeeded,pInputSem->semval,pOutputSem->semval);
tsem_up(omx_base_filter_Private->flush_all_condition);
tsem_down(omx_base_filter_Private->flush_condition);
pthread_mutex_lock(&omx_base_filter_Private->flush_mutex);
}
pthread_mutex_unlock(&omx_base_filter_Private->flush_mutex);
/*No buffer to process. So wait here*/
if((isInputBufferNeeded==OMX_TRUE && pInputSem->semval==0) &&
(omx_base_filter_Private->state != OMX_StateLoaded && omx_base_filter_Private->state != OMX_StateInvalid)) {
//Signaled from EmptyThisBuffer or FillThisBuffer or some thing else
DEBUG(DEB_LEV_FULL_SEQ, "Waiting for next input/output buffer\n");
tsem_down(omx_base_filter_Private->bMgmtSem);
}
if(omx_base_filter_Private->state == OMX_StateLoaded || omx_base_filter_Private->state == OMX_StateInvalid) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Buffer Management Thread is exiting\n",__func__);
break;
}
if((isOutputBufferNeeded==OMX_TRUE && pOutputSem->semval==0) &&
(omx_base_filter_Private->state != OMX_StateLoaded && omx_base_filter_Private->state != OMX_StateInvalid) &&
!(PORT_IS_BEING_FLUSHED(pInPort) || PORT_IS_BEING_FLUSHED(pOutPort))) {
//Signaled from EmptyThisBuffer or FillThisBuffer or some thing else
DEBUG(DEB_LEV_FULL_SEQ, "Waiting for next input/output buffer\n");
tsem_down(omx_base_filter_Private->bMgmtSem);
}
if(omx_base_filter_Private->state == OMX_StateLoaded || omx_base_filter_Private->state == OMX_StateInvalid) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Buffer Management Thread is exiting\n",__func__);
break;
}
DEBUG(DEB_LEV_FULL_SEQ, "Waiting for input buffer semval=%d in %s\n",pInputSem->semval, __func__);
if(pInputSem->semval>0 && isInputBufferNeeded==OMX_TRUE ) {
tsem_down(pInputSem);
if(pInputQueue->nelem>0){
inBufExchanged++;
isInputBufferNeeded=OMX_FALSE;
pInputBuffer = dequeue(pInputQueue);
if(pInputBuffer == NULL){
DEBUG(DEB_LEV_ERR, "Had NULL input buffer!!\n");
break;
}
}
}
/*When we have input buffer to process then get one output buffer*/
if(pOutputSem->semval>0 && isOutputBufferNeeded==OMX_TRUE) {
tsem_down(pOutputSem);
if(pOutputQueue->nelem>0){
outBufExchanged++;
isOutputBufferNeeded=OMX_FALSE;
pOutputBuffer = dequeue(pOutputQueue);
if(pOutputBuffer == NULL){
DEBUG(DEB_LEV_ERR, "Had NULL output buffer!! op is=%d,iq=%d\n",pOutputSem->semval,pOutputQueue->nelem);
break;
}
}
}
if(isInputBufferNeeded==OMX_FALSE) {
if(pInputBuffer->hMarkTargetComponent != NULL){
if((OMX_COMPONENTTYPE*)pInputBuffer->hMarkTargetComponent ==(OMX_COMPONENTTYPE *)openmaxStandComp) {
/*Clear the mark and generate an event*/
(*(omx_base_filter_Private->callbacks->EventHandler))
(openmaxStandComp,
omx_base_filter_Private->callbackData,
OMX_EventMark, /* The command was completed */
1, /* The commands was a OMX_CommandStateSet */
0, /* The state has been changed in message->messageParam2 */
pInputBuffer->pMarkData);
} else {
/*If this is not the target component then pass the mark*/
omx_base_filter_Private->pMark.hMarkTargetComponent = pInputBuffer->hMarkTargetComponent;
omx_base_filter_Private->pMark.pMarkData = pInputBuffer->pMarkData;
}
pInputBuffer->hMarkTargetComponent = NULL;
}
}
if(isInputBufferNeeded==OMX_FALSE && isOutputBufferNeeded==OMX_FALSE) {
if(omx_base_filter_Private->pMark.hMarkTargetComponent != NULL){
pOutputBuffer->hMarkTargetComponent = omx_base_filter_Private->pMark.hMarkTargetComponent;
pOutputBuffer->pMarkData = omx_base_filter_Private->pMark.pMarkData;
omx_base_filter_Private->pMark.hMarkTargetComponent = NULL;
omx_base_filter_Private->pMark.pMarkData = NULL;
}
pOutputBuffer->nTimeStamp = pInputBuffer->nTimeStamp;
if((pInputBuffer->nFlags & OMX_BUFFERFLAG_STARTTIME) == OMX_BUFFERFLAG_STARTTIME) {
DEBUG(DEB_LEV_FULL_SEQ, "Detected START TIME flag in the input buffer filled len=%d\n", (int)pInputBuffer->nFilledLen);
pOutputBuffer->nFlags = pInputBuffer->nFlags;
pInputBuffer->nFlags = 0;
}
if(omx_base_filter_Private->state == OMX_StateExecuting) {
if (omx_base_filter_Private->BufferMgmtCallback && pInputBuffer->nFilledLen > 0) {
(*(omx_base_filter_Private->BufferMgmtCallback))(openmaxStandComp, pInputBuffer, pOutputBuffer);
} else {
/*It no buffer management call back the explicitly consume input buffer*/
pInputBuffer->nFilledLen = 0;
}
} else if(!(PORT_IS_BEING_FLUSHED(pInPort) || PORT_IS_BEING_FLUSHED(pOutPort))) {
DEBUG(DEB_LEV_ERR, "In %s Received Buffer in non-Executing State(%x)\n", __func__, (int)omx_base_filter_Private->state);
} else {
pInputBuffer->nFilledLen = 0;
}
if((pInputBuffer->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS && pInputBuffer->nFilledLen==0) {
DEBUG(DEB_LEV_FULL_SEQ, "Detected EOS flags in input buffer filled len=%d\n", (int)pInputBuffer->nFilledLen);
pOutputBuffer->nFlags=pInputBuffer->nFlags;
pInputBuffer->nFlags=0;
(*(omx_base_filter_Private->callbacks->EventHandler))
(openmaxStandComp,
omx_base_filter_Private->callbackData,
OMX_EventBufferFlag, /* The command was completed */
1, /* The commands was a OMX_CommandStateSet */
pOutputBuffer->nFlags, /* The state has been changed in message->messageParam2 */
NULL);
omx_base_filter_Private->bIsEOSReached = OMX_TRUE;
}
if(omx_base_filter_Private->state==OMX_StatePause && !(PORT_IS_BEING_FLUSHED(pInPort) || PORT_IS_BEING_FLUSHED(pOutPort))) {
/*Waiting at paused state*/
tsem_wait(omx_base_filter_Private->bStateSem);
}
/*If EOS and Input buffer Filled Len Zero then Return output buffer immediately*/
if((pOutputBuffer->nFilledLen != 0) || ((pOutputBuffer->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) || (omx_base_filter_Private->bIsEOSReached == OMX_TRUE)) {
pOutPort->ReturnBufferFunction(pOutPort,pOutputBuffer);
outBufExchanged--;
pOutputBuffer=NULL;
isOutputBufferNeeded=OMX_TRUE;
}
}
if(omx_base_filter_Private->state==OMX_StatePause && !(PORT_IS_BEING_FLUSHED(pInPort) || PORT_IS_BEING_FLUSHED(pOutPort))) {
/*Waiting at paused state*/
tsem_wait(omx_base_filter_Private->bStateSem);
}
/*Input Buffer has been completely consumed. So, return input buffer*/
if((isInputBufferNeeded == OMX_FALSE) && (pInputBuffer->nFilledLen==0)) {
pInPort->ReturnBufferFunction(pInPort,pInputBuffer);
inBufExchanged--;
pInputBuffer=NULL;
isInputBufferNeeded=OMX_TRUE;
}
}
DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s of component %p\n", __func__, openmaxStandComp);
return NULL;
}
