void testEnableDisable()
{
MpFlowGraphBase* pFlowGraph = 0;
MpTestResource* pResource1 = 0;
MpTestResource* pResource2 = 0;
OsStatus res;
pFlowGraph = new MpFlowGraphBase(80, 8000);
pResource1 = new MpTestResource("test1", 2, 2, 2, 2);
pResource2 = new MpTestResource("test2", 2, 2, 2, 2);
res = pFlowGraph->addResource(*pResource1);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->addResource(*pResource2);
CPPUNIT_ASSERT(res == OS_SUCCESS);
CPPUNIT_ASSERT((pResource1->isEnabled() == FALSE) &&
(pResource2->isEnabled() == FALSE));
// enable all of the resources in the flow graph
res = pFlowGraph->enable();
CPPUNIT_ASSERT(res == OS_SUCCESS);
CPPUNIT_ASSERT(pResource1->isEnabled() && pResource2->isEnabled());
// now disable all of the the resources in the flow graph
res = pFlowGraph->disable();
CPPUNIT_ASSERT(res == OS_SUCCESS);
CPPUNIT_ASSERT((pResource1->isEnabled() == FALSE) &&
(pResource2->isEnabled() == FALSE));
delete pFlowGraph;
}
void testLinkAndResource()
{
MpFlowGraphBase* pFlowGraph = 0;
MpTestResource* pResource1 = 0;
MpTestResource* pResource2 = 0;
OsStatus res;
// ====== Test the addLink(), addResource(),
// removeLink() and removeResource() methods ======
pFlowGraph = new MpFlowGraphBase(80, 8000);
pResource1 = new MpTestResource("test1", 2, 2, 2, 2);
pResource2 = new MpTestResource("test2", 2, 2, 2, 2);
res = pFlowGraph->addResource(*pResource1);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->addResource(*pResource2);
CPPUNIT_ASSERT(res == OS_SUCCESS);
// connect pResource1 output port 0 --> pResource2 input port 0
res = pFlowGraph->addLink(*pResource1, 0, *pResource2, 0);
CPPUNIT_ASSERT(res == OS_SUCCESS);
// try connecting an invalid input port to a valid output port
res = pFlowGraph->addLink(*pResource1, 2, *pResource2, 1);
CPPUNIT_ASSERT(res == OS_INVALID_ARGUMENT);
// try connecting a valid input port to an invalid output port
res = pFlowGraph->addLink(*pResource1, 1, *pResource2, 2);
CPPUNIT_ASSERT(res == OS_INVALID_ARGUMENT);
// try removing a link on a port that doesn't exist
res = pFlowGraph->removeLink(*pResource1, 2);
CPPUNIT_ASSERT(res == OS_INVALID_ARGUMENT);
// remove the link and resources
res = pFlowGraph->removeLink(*pResource1, 0);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->removeResource(*pResource1);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->removeResource(*pResource2);
CPPUNIT_ASSERT(res == OS_SUCCESS);
delete pResource1;
delete pResource2;
delete pFlowGraph;
}
OsStatus MpResource::sendNotification(MpResNotificationMsg& msg)
{
OsStatus stat = OS_SUCCESS;
// Only send a notification if notifications are enabled.
if (areNotificationsEnabled() == TRUE)
{
MpFlowGraphBase* pFg = getFlowGraph();
assert(pFg != NULL);
msg.setConnectionId(mConnectionId);
msg.setStreamId(mStreamId);
stat = pFg->postNotification(msg);
}
return stat;
}
void testDestroyResources()
{
MpFlowGraphBase* pFlowGraph = 0;
MpTestResource* pResource1 = 0;
MpTestResource* pResource2 = 0;
OsStatus res;
pFlowGraph = new MpFlowGraphBase(80, 8000);
pResource1 = new MpTestResource("test1", 2, 2, 2, 2);
pResource2 = new MpTestResource("test2", 2, 2, 2, 2);
res = pFlowGraph->addResource(*pResource1);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->addResource(*pResource2);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->addLink(*pResource1, 0, *pResource2, 0);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->destroyResources();
CPPUNIT_ASSERT((res == OS_SUCCESS) &&
(pFlowGraph->numResources() == 0) &&
(pFlowGraph->numLinks() == 0));
delete pFlowGraph;
}
// Directs the media processing task to add the flow graph to its
// set of managed flow graphs. The flow graph must be in the
// MpFlowGraphBase::STOPPED state when this method is invoked.
// Returns OS_INVALID_ARGUMENT if the flow graph is not in the STOPPED state.
// Otherwise returns OS_SUCCESS to indicate that the flow graph will be added
// to the set of managed flow graphs at the start of the next frame
// processing interval.
OsStatus MpMediaTask::manageFlowGraph(MpFlowGraphBase& rFlowGraph)
{
MpMediaTaskMsg msg(MpMediaTaskMsg::MANAGE, &rFlowGraph);
OsStatus res;
if (rFlowGraph.getState() != MpFlowGraphBase::STOPPED) {
// PRINTF("MpMediaTask::manageFlowGraph: error!\n", 0,0,0,0,0,0);
return OS_INVALID_ARGUMENT;
}
res = postMessage(msg, OsTime::NO_WAIT);
assert(res == OS_SUCCESS);
return OS_SUCCESS;
}
// Directs the media processing task to add the flow graph to its
// set of managed flow graphs. The flow graph must be in the
// MpFlowGraphBase::STOPPED state when this method is invoked.
// Returns OS_INVALID_ARGUMENT if the flow graph is not in the STOPPED state.
// Otherwise returns OS_SUCCESS to indicate that the flow graph will be added
// to the set of managed flow graphs at the start of the next frame
// processing interval.
OsStatus MpMediaTask::manageFlowGraph(MpFlowGraphBase& rFlowGraph)
{
OsEvent event;
MpMediaTaskMsg msg(MpMediaTaskMsg::MANAGE, &rFlowGraph, &event);
OsStatus res;
if (rFlowGraph.getState() != MpFlowGraphBase::STOPPED) {
// PRINTF("MpMediaTask::manageFlowGraph: error!\n", 0,0,0,0,0,0);
return OS_INVALID_ARGUMENT;
}
res = postMessage(msg, OsTime::NO_WAIT_TIME);
assert(res == OS_SUCCESS);
// wait until flowgraph is managed
event.wait();
return OS_SUCCESS;
}
void testCreators()
{
MpFlowGraphBase* pFlowGraph = 0;
MpTestResource* pResource1 = 0;
MpTestResource* pResource2 = 0;
OsStatus res;
// verify that we can create and delete MpFlowGraphBase objects
pFlowGraph = new MpFlowGraphBase(80, 8000);
// verify that the initial state information is sensible
CPPUNIT_ASSERT(pFlowGraph->getState() == MpFlowGraphBase::STOPPED);
CPPUNIT_ASSERT(pFlowGraph->numLinks() == 0);
CPPUNIT_ASSERT(pFlowGraph->numFramesProcessed() == 0);
CPPUNIT_ASSERT(pFlowGraph->numResources() == 0);
CPPUNIT_ASSERT(!pFlowGraph->isStarted());
delete pFlowGraph;
// when we have a flow graph that contains resources and links,
// verify that destroying the flow graph also gets rid of the resources
// and links.
pFlowGraph = new MpFlowGraphBase(80, 8000);
pResource1 = new MpTestResource("test1", 1, 1, 1, 1);
pResource2 = new MpTestResource("test2", 1, 1, 1, 1);
res = pFlowGraph->addResource(*pResource1);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->addResource(*pResource2);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->addLink(*pResource1, 0, *pResource2, 0);
CPPUNIT_ASSERT(res == OS_SUCCESS);
delete pFlowGraph;
}
void testSamplesPerFrameAndSec()
{
MpFlowGraphBase* pFlowGraph = 0;
MpTestResource* pResource1 = 0;
OsStatus res;
pFlowGraph = new MpFlowGraphBase(80, 8000);
pResource1 = new MpTestResource("test1", 2, 2, 2, 2);
CPPUNIT_ASSERT_EQUAL(80, pFlowGraph->getSamplesPerFrame());
CPPUNIT_ASSERT_EQUAL(8000, pFlowGraph->getSamplesPerSec());
res = pFlowGraph->addResource(*pResource1);
CPPUNIT_ASSERT(res == OS_SUCCESS);
// Call processFrame() on the resource and look at the initial settings
pResource1->processFrame();
CPPUNIT_ASSERT_EQUAL(80, pResource1->mLastDoProcessArgs.samplesPerFrame);
CPPUNIT_ASSERT_EQUAL(8000, pResource1->mLastDoProcessArgs.samplesPerSecond);
res = pFlowGraph->setSamplesPerFrame(160);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->setSamplesPerSec(32000);
CPPUNIT_ASSERT(res == OS_SUCCESS);
CPPUNIT_ASSERT_EQUAL(160, pFlowGraph->getSamplesPerFrame());
CPPUNIT_ASSERT_EQUAL(32000, pFlowGraph->getSamplesPerSec());
// Call processFrame() on the resource and look at the revised settings
pResource1->processFrame();
CPPUNIT_ASSERT_EQUAL(160, pResource1->mLastDoProcessArgs.samplesPerFrame);
CPPUNIT_ASSERT_EQUAL(32000, pResource1->mLastDoProcessArgs.samplesPerSecond);
delete pFlowGraph;
}
// Handles the WAIT_FOR_SIGNAL message.
// Performs the one-per-tick media processing as directed by the flow graph.
// Returns TRUE if the message was handled, otherwise FALSE.
UtlBoolean MpMediaTask::handleWaitForSignal(MpMediaTaskMsg* pMsg)
{
OsStatus res;
#ifdef TEST_TASK_LOAD
OsTime maxAllowedTime(mLimitUsecs*1000);
OsTime processingStartTime;
OsDateTime::getCurTime(processingStartTime);
#endif
// reset the handleMessage error count
// mHandleMsgErrs = 0;
mWaitForSignal = FALSE;
// When this message is received we know that:
// 1) We have received a frame start signal
// 2) All of the messages that had been queued for this task at the
// time the frame start signal occurred have been processed.
// Call processNextFrame() for each of the "started" flow graphs
UtlHashBagIterator itor(mManagedFlowGraphs);
UtlPtr<MpFlowGraphBase>* ptr = NULL;
MpFlowGraphBase* pFlowGraph = NULL;
#if FRAME_PROCESSING_THREADS > 0
// let worker threads process frames
int counter = 0;
while(ptr = (UtlPtr<MpFlowGraphBase>*)itor())
{
pFlowGraph = ptr->getValue();
assert(pFlowGraph);
if (pFlowGraph && pFlowGraph->isStarted())
{
m_processingThreads[counter]->addFlowgraphForProcessing(pFlowGraph);
counter = (counter + 1) % FRAME_PROCESSING_THREADS;
}
}
// process all frames in threads
for (int i = 0; i < FRAME_PROCESSING_THREADS; i++)
{
m_processingThreads[i]->processWork();
}
// now synchronize all threads - a barrier
for (int i = 0; i < FRAME_PROCESSING_THREADS; i++)
{
m_processingThreads[i]->waitUntilDone();
}
#else
// let MpMediaTask process all frames
while(ptr = (UtlPtr<MpFlowGraphBase>*)itor())
{
pFlowGraph = ptr->getValue();
assert(pFlowGraph);
if (pFlowGraph->isStarted())
{
res = pFlowGraph->processNextFrame();
assert(res == OS_SUCCESS);
}
}
#endif
assert(!mWaitForSignal);
mProcessedCnt++;
mWaitForSignal = TRUE;
if (nFrameStartMsgs > 0)
{
nFrameStartMsgs--;
}
#ifdef TEST_TASK_LOAD
OsTime processingStopTime;
OsDateTime::getCurTime(processingStopTime);
if (processingStopTime - processingStartTime > maxAllowedTime)
{
// signal overload to skip processing frames
m_bTaskOverloaded = TRUE;
}
else
{
// disable overload flag, we will process even big backlog of frame start signals
m_bTaskOverloaded = FALSE;
}
#endif
return TRUE;
}
void testManagedAndUnmanagedFlowGraph()
{
MpFlowGraphBase* pFlowGraph = 0;
MpMediaTask* pMediaTask = 0;
OsStatus res;
// Test 1: Create an empty flow graph and manage it
pMediaTask = MpMediaTask::getMediaTask(10);
pFlowGraph = new MpFlowGraphBase(30, 30);
res = pMediaTask->manageFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = MpMediaTask::signalFrameStart(); // send a signal to the task
CPPUNIT_ASSERT(res == OS_SUCCESS); // and give it a chance to run
// NOTE: original delay of 20 was tempermental, I increased
// this to 100 to reduce the chance of this happening to
// hopefully 0% - DLH
OsTask::delay(100);
CPPUNIT_ASSERT_EQUAL(1, pMediaTask->numManagedFlowGraphs());
// Test 2: Invoke manageFlowGraph() with the same flow graph
// (will increment the numHandledMsgErrs() count for that
// frame processing interval but should otherwise have no
// effect)
res = pMediaTask->manageFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = MpMediaTask::signalFrameStart(); // send a signal to the task
CPPUNIT_ASSERT(res == OS_SUCCESS); // and give it a chance to run
OsTask::delay(20);
CPPUNIT_ASSERT_EQUAL(1, pMediaTask->numManagedFlowGraphs());
CPPUNIT_ASSERT_EQUAL(1, pMediaTask->numHandledMsgErrs());
// Test 3: Unmanage the flow graph
res = pMediaTask->unmanageFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = MpMediaTask::signalFrameStart(); // send a signal to the task
CPPUNIT_ASSERT(res == OS_SUCCESS); // and give it a chance to run
OsTask::delay(20);
CPPUNIT_ASSERT_EQUAL(0, pMediaTask->numManagedFlowGraphs());
// Test 4: Unmanage a flow graph which is not currently managed
// (will increment the numHandledMsgErrs() count for that
// frame processing interval but should otherwise have no
// effect)
res = pMediaTask->unmanageFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = MpMediaTask::signalFrameStart(); // send a signal to the task
CPPUNIT_ASSERT(res == OS_SUCCESS); // and give it a chance to run
OsTask::delay(20);
CPPUNIT_ASSERT_EQUAL(0, pMediaTask->numManagedFlowGraphs());
CPPUNIT_ASSERT_EQUAL(1, pMediaTask->numHandledMsgErrs());
// Test 5: Attempt to manage a flow graph that is not in the
// MpFlowGraphBase::STOPPED state
res = pFlowGraph->start(); // send the flow graph a start
CPPUNIT_ASSERT(res == OS_SUCCESS); // command and a signal to
res = pFlowGraph->processNextFrame(); // process its messages
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pMediaTask->manageFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_INVALID_ARGUMENT);
res = pFlowGraph->stop(); // send the flow graph a stop
CPPUNIT_ASSERT(res == OS_SUCCESS); // command and a signal to
res = pFlowGraph->processNextFrame(); // process its messages
CPPUNIT_ASSERT(res == OS_SUCCESS);
// Test 6: Unmanage a flow graph that is "started"
res = pMediaTask->manageFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pMediaTask->startFlowGraph(*pFlowGraph); // start the flow graph
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = MpMediaTask::signalFrameStart(); // send a signal to the task
CPPUNIT_ASSERT(res == OS_SUCCESS); // and give it a chance to run
OsTask::delay(20);
res = pMediaTask->unmanageFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = MpMediaTask::signalFrameStart(); // send a signal to the task
CPPUNIT_ASSERT(res == OS_SUCCESS); // and give it a chance to run
OsTask::delay(20);
// verify that the flow graph has been stopped and is unmanaged
CPPUNIT_ASSERT(pFlowGraph->getState() == MpFlowGraphBase::STOPPED);
CPPUNIT_ASSERT_EQUAL(0, pMediaTask->numManagedFlowGraphs());
CPPUNIT_ASSERT_EQUAL(0, pMediaTask->numStartedFlowGraphs());
delete pFlowGraph;
}
void testStartAndStopFlowGraph()
{
MpFlowGraphBase* pFlowGraph = 0;
MpMediaTask* pMediaTask = 0;
OsStatus res;
// Test 1: Set the time limit to twice its original value
pMediaTask = MpMediaTask::getMediaTask(10);
pFlowGraph = new MpFlowGraphBase(30, 30);
pMediaTask->numHandledMsgErrs(); // clear count
// Test 1: Attempt to start a flow graph that is not being managed
//CPPUNIT_ASSERT_EQUAL(1, pMediaTask->numStartedFlowGraphs());
res = pMediaTask->startFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = MpMediaTask::signalFrameStart(); // signal the media task and
CPPUNIT_ASSERT(res == OS_SUCCESS); // give it a chance to run
OsTask::delay(20);
// NOTE: Original test code had "1", not sure what's correct
CPPUNIT_ASSERT_EQUAL(1, pMediaTask->numHandledMsgErrs());
CPPUNIT_ASSERT_EQUAL(0, pMediaTask->numStartedFlowGraphs());
// Test 2: Start a flow graph that is managed
pMediaTask->numHandledMsgErrs(); // clear the count
res = pMediaTask->manageFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pMediaTask->startFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = MpMediaTask::signalFrameStart(); // signal the media task and
CPPUNIT_ASSERT(res == OS_SUCCESS); // give it a chance to run
OsTask::delay(20);
CPPUNIT_ASSERT_EQUAL(0, pMediaTask->numHandledMsgErrs());
CPPUNIT_ASSERT_EQUAL(1, pMediaTask->numStartedFlowGraphs());
CPPUNIT_ASSERT(pFlowGraph->isStarted());
// Test 3: Attempt to start the same flow graph again
pMediaTask->numHandledMsgErrs(); // clear the count
res = pMediaTask->startFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = MpMediaTask::signalFrameStart(); // signal the media task and
CPPUNIT_ASSERT(res == OS_SUCCESS); // give it a chance to run
OsTask::delay(20);
//CPPUNIT_ASSERT_EQUAL(0, pMediaTask->numHandledMsgErrs());
CPPUNIT_ASSERT_EQUAL(1, pMediaTask->numStartedFlowGraphs());
// Test 4: Stop the flow graph
pMediaTask->numHandledMsgErrs(); // clear the count
res = pMediaTask->stopFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = MpMediaTask::signalFrameStart(); // signal the media task and
CPPUNIT_ASSERT(res == OS_SUCCESS); // give it a chance to run
OsTask::delay(20);
CPPUNIT_ASSERT_EQUAL(0, pMediaTask->numHandledMsgErrs());
CPPUNIT_ASSERT_EQUAL(0, pMediaTask->numStartedFlowGraphs());
CPPUNIT_ASSERT(!pFlowGraph->isStarted());
// Test 5: Attempt to stop the same flow graph again
pMediaTask->numHandledMsgErrs(); // clear the count
res = pMediaTask->stopFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = MpMediaTask::signalFrameStart(); // signal the media task and
CPPUNIT_ASSERT(res == OS_SUCCESS); // give it a chance to run
OsTask::delay(20);
//CPPUNIT_ASSERT_EQUAL(1, pMediaTask->numHandledMsgErrs());
CPPUNIT_ASSERT_EQUAL(0, pMediaTask->numStartedFlowGraphs());
CPPUNIT_ASSERT(!pFlowGraph->isStarted());
// Test 6: Attempt to stop a flow graph that is not being managed
pMediaTask->numHandledMsgErrs(); // clear the count
res = pMediaTask->unmanageFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pMediaTask->stopFlowGraph(*pFlowGraph);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = MpMediaTask::signalFrameStart(); // signal the media task and
CPPUNIT_ASSERT(res == OS_SUCCESS); // give it a chance to run
OsTask::delay(20);
CPPUNIT_ASSERT_EQUAL(1, pMediaTask->numHandledMsgErrs());
CPPUNIT_ASSERT_EQUAL(0, pMediaTask->numStartedFlowGraphs());
CPPUNIT_ASSERT(!pFlowGraph->isStarted());
delete pFlowGraph;
}
// lookupResource(), numLinks(), numFramesProcessed() and numResources()
void testAccessors()
{
MpFlowGraphBase* pFlowGraph = 0;
MpTestResource* pResource1 = 0;
MpTestResource* pResource2 = 0;
MpResource* pLookupRes = 0;
OsStatus res;
pFlowGraph = new MpFlowGraphBase(80, 8000);
CPPUNIT_ASSERT(pFlowGraph->numResources() == 0);
CPPUNIT_ASSERT(pFlowGraph->numLinks() == 0);
CPPUNIT_ASSERT(pFlowGraph->numFramesProcessed() == 0);
pResource1 = new MpTestResource("resource1", 4, 4, 4, 4);
pResource2 = new MpTestResource("resource2", 4, 4, 4, 4);
res = pFlowGraph->addResource(*pResource1);
CPPUNIT_ASSERT((res == OS_SUCCESS) && (pFlowGraph->numResources() == 1));
res = pFlowGraph->addResource(*pResource2);
CPPUNIT_ASSERT((res == OS_SUCCESS) && (pFlowGraph->numResources() == 2));
res = pFlowGraph->lookupResource("resource1", pLookupRes);
CPPUNIT_ASSERT((res == OS_SUCCESS) && (pLookupRes == pResource1));
res = pFlowGraph->lookupResource("resource2", pLookupRes);
CPPUNIT_ASSERT((res == OS_SUCCESS) && (pLookupRes == pResource2));
res = pFlowGraph->lookupResource("unknown", pLookupRes);
CPPUNIT_ASSERT(res == OS_NOT_FOUND);
res = pFlowGraph->addLink(*pResource1, 0, *pResource2, 0);
CPPUNIT_ASSERT((res == OS_SUCCESS) && (pFlowGraph->numLinks() == 1));
res = pFlowGraph->addLink(*pResource1, 1, *pResource2, 1);
CPPUNIT_ASSERT((res == OS_SUCCESS) && (pFlowGraph->numLinks() == 2));
res = pFlowGraph->processNextFrame();
CPPUNIT_ASSERT((res == OS_SUCCESS) && (pFlowGraph->numFramesProcessed() == 1));
res = pFlowGraph->processNextFrame();
CPPUNIT_ASSERT((res == OS_SUCCESS) && (pFlowGraph->numFramesProcessed() == 2));
res = pFlowGraph->removeLink(*pResource1, 0);
CPPUNIT_ASSERT((res == OS_SUCCESS) && (pFlowGraph->numLinks() == 1));
res = pFlowGraph->removeLink(*pResource1, 1);
CPPUNIT_ASSERT((res == OS_SUCCESS) && (pFlowGraph->numLinks() == 0));
res = pFlowGraph->removeResource(*pResource2);
CPPUNIT_ASSERT((res == OS_SUCCESS) && (pFlowGraph->numResources() == 1));
res = pFlowGraph->removeResource(*pResource1);
CPPUNIT_ASSERT((res == OS_SUCCESS) && (pFlowGraph->numResources() == 0));
delete pResource1;
delete pResource2;
delete pFlowGraph;
}
void testStartAndStop()
{
MpFlowGraphBase* pFlowGraph = 0;
OsStatus res;
pFlowGraph = new MpFlowGraphBase(80, 8000);
CPPUNIT_ASSERT(!pFlowGraph->isStarted()); // verify the flow graph is not STARTED
CPPUNIT_ASSERT(MpFlowGraphBase::STOPPED == pFlowGraph->getState());
res = pFlowGraph->start(); // now start it
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->processNextFrame();
CPPUNIT_ASSERT((res == OS_SUCCESS) && pFlowGraph->isStarted());
CPPUNIT_ASSERT(MpFlowGraphBase::STARTED == pFlowGraph->getState());
res = pFlowGraph->stop(); // now stop it again
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->processNextFrame();
CPPUNIT_ASSERT((res == OS_SUCCESS) && !pFlowGraph->isStarted());
CPPUNIT_ASSERT(MpFlowGraphBase::STOPPED == pFlowGraph->getState());
delete pFlowGraph;
}
/**
* FAILS : Segmention fault
*/
void testProcessNextFrame()
{
// Set up a flow graph with two resources (resource1 and resource2). Both
// resources have 4 inputs and 4 outputs. All four outputs of resource1
// are connected to the corresponding inputs of resource2. The resources
// are further configured to behave as follows for each frame processing
// interval.
//
// Resource 1: | Resource 2:
// Creates output buffers on | Processes input buffers received on
// output ports 0, 2 and 3. | input ports 0, 1 and 2.
//
// resource1 Output 0 --> Input 0
// ignores Output 1 (NULL) --> Input 1
// its Output 2 --> Input 2
// inputs Output 3 --> Input 3 (not processed)
//
// The net result is that each frame time, resource2 should receive
// non-NULL buffers on input ports 0, 2 and 3. Since resource2 is not
// processing input buffers on input port 3, for each frame, the old
// buffer on input port 3 will be discarded to make way for a new buffer.
MpFlowGraphBase* pFlowGraph = 0;
MpTestResource* pResource1 = 0;
MpTestResource* pResource2 = 0;
OsStatus res;
mpStartUp(8000, 80, 6*10, 0);
pFlowGraph = new MpFlowGraphBase(80, 8000);
pResource1 = new MpTestResource("resource1", 4, 4, 4, 4);
pResource2 = new MpTestResource("resource2", 4, 4, 4, 4);
res = pFlowGraph->addResource(*pResource1);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->addResource(*pResource2);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->addLink(*pResource1, 0, *pResource2, 0);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->addLink(*pResource1, 1, *pResource2, 1);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->addLink(*pResource1, 2, *pResource2, 2);
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->addLink(*pResource1, 3, *pResource2, 3);
CPPUNIT_ASSERT(res == OS_SUCCESS);
// For resource1, create new buffers on output ports 0, 2 and 3 and
// ignore all input buffers (Note: there shouldn't be any)
pResource1->setGenOutBufMask(0xd);
pResource1->setProcessInBufMask(0x0);
// For resource2, process input buffers that arrive input ports 0, 1 and 2.
pResource2->setGenOutBufMask(0x0);
pResource2->setProcessInBufMask(0x7);
CPPUNIT_ASSERT(pResource1->numFramesProcessed() == 0);
CPPUNIT_ASSERT(pResource2->numFramesProcessed() == 0);
// Enable the flow graph
res = pFlowGraph->enable();
CPPUNIT_ASSERT(res == OS_SUCCESS);
// Start the flow graph
res = pFlowGraph->start();
CPPUNIT_ASSERT(res == OS_SUCCESS);
// Process two frames
res = pFlowGraph->processNextFrame();
CPPUNIT_ASSERT(res == OS_SUCCESS);
res = pFlowGraph->processNextFrame();
CPPUNIT_ASSERT(res == OS_SUCCESS);
for (int i = 0; i < 3; i++)
{
CPPUNIT_ASSERT((pResource1->mLastDoProcessArgs.inBufs[i] == NULL) &&
(pResource1->mLastDoProcessArgs.outBufs[i] == NULL) &&
(pResource2->mLastDoProcessArgs.inBufs[i] == NULL) &&
(pResource2->mLastDoProcessArgs.outBufs[i] == NULL));
}
CPPUNIT_ASSERT((pResource1->numFramesProcessed() == 2) &&
(pResource1->mLastDoProcessArgs.inBufsSize == 4) &&
(pResource1->mLastDoProcessArgs.outBufsSize == 4) &&
(pResource2->numFramesProcessed() == 2));
// Stop the flow graph
res = pFlowGraph->stop();
CPPUNIT_ASSERT(res == OS_SUCCESS);
// Request processing of another frame so that the STOP_FLOWGRAPH
// message gets handled
res = pFlowGraph->processNextFrame();
CPPUNIT_ASSERT(res == OS_SUCCESS);
delete pFlowGraph;
}
