~CThreadT()
{
vcos_event_flags_set(&m_EventFlags, s_nTerminationFlag, VCOS_OR);
void* pData;
vcos_thread_join(&m_Thread, &pData);
vcos_event_flags_delete(&m_EventFlags);
vcos_event_delete(&m_InitializedEvent);
}
static void
signal_event( VC_POOL_T *pool )
{
//either call the callback or signal the event
//the use of both together is prohibited
if (pool->callback)
pool->callback(pool->callback_cookie);
else
vcos_event_flags_set( &pool->event, RELEASE_EVENT, VCOS_OR );
}
static int set_operations_test()
{
VCOS_EVENT_FLAGS_T event;
int passed = 1;
if(vcos_event_flags_create(&event,"test") != VCOS_SUCCESS)
passed = 0;
else
{
check_value(&event, 0, 1, &passed);
vcos_event_flags_set(&event, 1, VCOS_AND);
check_value(&event, 0, 1, &passed);
vcos_event_flags_set(&event, 1, VCOS_OR);
check_value(&event, 1, 0, &passed);
vcos_event_flags_set(&event, 8, VCOS_OR);
check_value(&event, 9, 0, &passed);
vcos_event_flags_set(&event, 96, VCOS_OR);
check_value(&event, 9|96, 0, &passed);
vcos_event_flags_set(&event, 65|1024, VCOS_AND);
check_value(&event, 65, 0, &passed);
vcos_event_flags_set(&event, -1, VCOS_OR);
check_value(&event, -1, 1, &passed);
vcos_event_flags_delete(&event);
}
return passed;
}
static void run_waiters(WAITER_T *waiter, int num, int *sleep, uint32_t *bitmask, VCOS_EVENTGROUP_OPERATION_T *operation,
int32_t *suspend, int set_sleep, uint32_t set_bitmask, VCOS_STATUS_T *expected, uint32_t after, int *passed)
{
int i;
uint32_t set;
VCOS_STATUS_T st;
for(i=0; i<num; i++)
{
waiter[i].sleep_first = sleep ? sleep[i] : 0;
waiter[i].bitmask = bitmask[i];
waiter[i].operation = operation[i];
waiter[i].suspend = suspend[i];
vcos_semaphore_post(&waiter[i].go);
}
if(set_sleep)
vcos_sleep(set_sleep);
vcos_log("ORring in 0x%x", set_bitmask);
vcos_event_flags_set(waiter[0].event, set_bitmask, VCOS_OR);
for(i=0; i<num; i++)
{
vcos_semaphore_wait(&waiter[i].done);
if(waiter[i].result != expected[i] || (waiter[i].result == VCOS_SUCCESS && waiter[i].retrieved_bits != set_bitmask))
*passed = 0;
}
st = vcos_event_flags_get(waiter[0].event, -1, VCOS_OR_CONSUME, 0, &set);
if (after == 0 && st != VCOS_EAGAIN)
{
// we were expecting to retrieve nothing this time, but instead we got something!
*passed = 0;
vcos_log("run_waiters: got unexpected events back afterwards");
}
else if (after && (st != VCOS_SUCCESS) && (set != after))
{
// we were expecting to retrieve something, but instead got nothing, or not the right thing!
vcos_log("run_waiters: got wrong events back afterwards");
*passed = 0;
}
}
static void try_get_value(int *num, VCOS_EVENT_FLAGS_T *event, uint32_t start, uint32_t bitmask,
VCOS_OPTION operation, VCOS_STATUS_T expected, int after, int *passed)
{
VCOS_STATUS_T rc;
uint32_t set = 0;
vcos_event_flags_get(event, -1, VCOS_OR_CONSUME, 0, &set);
vcos_event_flags_set(event, start, VCOS_OR);
VCOS_TRACE("%s: mask %x op %s", __FUNCTION__, bitmask, op2str(operation));
if((rc=vcos_event_flags_get(event, bitmask, operation, 0, &set)) != expected)
{
*passed = 0;
}
if(expected == VCOS_SUCCESS && set != start)
{
*passed = 0;
}
check_value(event, after, 1, passed);
}
static int create_test()
{
int passed = 1;
VCOS_EVENT_FLAGS_T events[MAX_TESTED];
int i;
for(i=0; i<MAX_TESTED; i++)
if(vcos_event_flags_create(events+i,"test") != VCOS_SUCCESS)
passed = 0;
for(i=0; i<MAX_TESTED; i+=2)
vcos_event_flags_delete(events+i);
for(i=0; i<MAX_TESTED; i+=2)
if(vcos_event_flags_create(events+i,"test") != VCOS_SUCCESS)
passed = 0;
if(passed)
{
/* see if the bits appear to be independent */
for(i=0; i<MAX_TESTED; i++)
vcos_event_flags_set(events+i, i | (1<<i), VCOS_OR);
for(i=0; i<MAX_TESTED; i++)
{
uint32_t set;
if(vcos_event_flags_get(events+i, -1, VCOS_OR, VCOS_NO_SUSPEND, &set) != VCOS_SUCCESS)
passed = 0;
if(set != (i | (1<<i)))
passed = 0;
}
for(i=0; i<MAX_TESTED; i++)
vcos_event_flags_delete(events+i);
}
return passed;
}
OMX_ERRORTYPE CComponent::EventHandler(OMX_EVENTTYPE eEvent, OMX_U32 nData1, OMX_U32 nData2, OMX_PTR pEventData)
{
switch (eEvent)
{
case OMX_EventCmdComplete:
{
switch (nData1)
{
case OMX_CommandStateSet:
vcos_event_signal(&m_StateChangedEvent);
break;
case OMX_CommandPortEnable:
case OMX_CommandPortDisable:
{
CPortMap::iterator PortIterator = m_Ports.find(nData2);
if (PortIterator != m_Ports.end())
{
if (nData1 == OMX_CommandPortEnable)
{
PortIterator->second->OnEnabled();
}
else if (nData1 == OMX_CommandPortDisable)
{
PortIterator->second->OnDisabled();
}
}
}
break;
case OMX_CommandFlush:
{
CPortMap::iterator PortIterator = m_Ports.find(nData2);
if (PortIterator != m_Ports.end())
{
PortIterator->second->OnFlushed();
}
}
break;
default:
break;
}
}
break;
case OMX_EventPortSettingsChanged:
if (m_pGraph)
{
CComponentEvent Event;
Event.m_EventType = OMX_EventPortSettingsChanged;
Event.m_nData1 = nData1;
Event.m_nData2 = nData2;
Event.m_pEventData = pEventData;
{
CHECK_VCOS(vcos_mutex_lock(&m_EventQueueMutex), "failed to lock event queue mutex");
m_EventQueue.push_back(Event);
vcos_mutex_unlock(&m_EventQueueMutex);
}
vcos_event_flags_set(&m_EventThread.GetEventFlags(), s_nNewEventFlag, VCOS_OR);
}
break;
case OMX_EventError:
std::cerr << "Error: Component " << m_sName << " generated error " << Omx::OmxError(static_cast<OMX_ERRORTYPE>(nData1)) << std::endl;
break;
default:
break;
}
}
static int create_test()
{
int passed = 1;
VCOS_SEMAPHORE_T semas[MAX_TESTED];
GUARD_T guard;
int i;
for(i=0; i<MAX_TESTED; i++)
{
if(vcos_semaphore_create(semas+i, "sem", i) != VCOS_SUCCESS)
{
vcos_assert(0);
passed = 0;
}
}
for(i=0; i<MAX_TESTED; i+=2)
vcos_semaphore_delete(semas+i);
for(i=0; i<MAX_TESTED; i+=2)
if(vcos_semaphore_create(semas+i, "sem2", i) != VCOS_SUCCESS)
passed = 0;
if(passed)
{
if(guard_init(&guard) < 0)
passed = 0;
else
{
/* see if the values appear to be independent */
for(i=0; i<MAX_TESTED && passed; i++)
{
int j;
guard.wait[0] = 10;
guard.post[0] = 1;
guard.wait[1] = 10;
guard.post[1] = 100;
guard.guard = semas+i;
vcos_semaphore_post(&guard.go);
/* wait for one more than we set, the first wait by the guard
* should timeout, and it will post one more time. We should
* then wake up here, and set the event, so the second wait
* shouldn't timeout.
*/
for(j=0; j<i+1; j++)
vcos_semaphore_wait(semas+i);
vcos_event_flags_set(&guard.event, 1, VCOS_OR);
vcos_semaphore_wait(&guard.done);
if(!guard.timeout[0] || guard.timeout[1])
passed = 0;
}
guard_deinit(&guard, &passed);
}
for(i=0; i<MAX_TESTED; i++)
vcos_semaphore_delete(semas+i);
}
return passed;
}
