oex::oexBOOL CLvRtspClient::InitThread( oex::oexPVOID x_pData )
{_STT();
if ( !ThreadOpen( m_sUrl, m_bVideo, m_bAudio, &m_mParams ) )
{ ThreadDestroy();
return oex::oexFALSE;
} // end if
if ( !m_pRtspClient )
{ ThreadDestroy();
return oex::oexFALSE;
} // end if
return oex::oexTRUE;
}
//=============================================================================
int _tmain(int argc, _TCHAR* argv[]) {
bool shutdown = false;
ThreadInit();
Thread * mainThread = ThreadRegister("main");
Thread * childThread = ThreadCreate("test", 0, ThreadProc, &shutdown);
ThreadLogAllThreads();
shutdown = true;
ThreadDestroy(childThread); childThread = NULL;
ThreadUnregister(mainThread); mainThread = NULL;
ThreadDestroy();
return 0;
}
oex::oexINT CLvRtspClient::EndThread( oex::oexPVOID x_pData )
{_STT();
ThreadDestroy();
return 0;
}
void cleanUp() {
threadRun = false;
ThreadWait(t);
ThreadDestroy(t);
MutexDestroy(mutex);
getClientSocket().close();
Net::cleanup();
}
TInt CTestCondwait::TestCond411()
{
int errsum=0, err = 0;
int retval = 0;
ThreadData lThreadData;
sem_t lSignalSemaphore;
sem_t lSuspendSemaphore;
sem_t lTestSemaphore;
pthread_mutex_t lTestMutex;
pthread_cond_t lTestCondVar;
pthread_condattr_t lCondAttr;
pthread_mutexattr_t lTestMutexAttr;
pthread_mutexattr_t defaultattr;
pthread_mutexattr_t errorcheckattr;
pthread_mutexattr_t recursiveattr;
pthread_mutexattr_init(&defaultattr);
pthread_mutexattr_init(&errorcheckattr);
pthread_mutexattr_init(&recursiveattr);
pthread_mutexattr_settype(&errorcheckattr,PTHREAD_MUTEX_ERRORCHECK);
pthread_mutexattr_settype(&recursiveattr,PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_t l_staticmutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t l_errorcheckmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
pthread_mutex_t l_recursivemutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
pthread_cond_t l_staticcondvar = PTHREAD_COND_INITIALIZER;
CommonData lCommonData;
lCommonData.iStaticMutex = &l_staticmutex;
lCommonData.iErrorCheckMutex = &l_errorcheckmutex;
lCommonData.iRecursiveMutex = &l_recursivemutex;
lCommonData.iStaticCondVar = &l_staticcondvar;
retval = sem_init(&lSignalSemaphore,0,0);
if(retval != 0)
{
return retval;
}
retval = sem_init(&lSuspendSemaphore,0,0);
if(retval != 0)
{
return retval;
}
lThreadData.iSignalSemaphore = &lSignalSemaphore;
lThreadData.iSuspendSemaphore = &lSuspendSemaphore;
lThreadData.iTestSemaphore = &lTestSemaphore;
lThreadData.iTestMutex = &lTestMutex;
lThreadData.iTestMutexAttr = &lTestMutexAttr;
lThreadData.iTestCondVar = &lTestCondVar;
lThreadData.iDefaultAttr = &defaultattr;
lThreadData.iErrorcheckAttr = &errorcheckattr;
lThreadData.iRecursiveAttr = &recursiveattr;
lThreadData.iCondAttr = &lCondAttr;
for (int loop = 0; loop < EThreadMain; loop++)
{
g_spinFlag[loop] = true;
}
lThreadData.iSuspending = false;
lThreadData.iSpinCounter = 0;
lThreadData.iCurrentCommand = -1;
lThreadData.iSelf = EThreadMain;
lThreadData.iValue = 0;
lThreadData.iRetValue = 0;
lThreadData.ierrno = 0;
lThreadData.iExpectederrno = 0;
lThreadData.iTimes = 0;
lThreadData.iStopped = false;
lThreadData.iCommonData = &lCommonData;
retval = CondInit(&lThreadData);
retval = MutexInitNULL(&lThreadData);
fp=func;
retval = ThreadCreate(&lThreadData, (void*) EThread1);
WaitTillSuspended(&lThreadData, (void*) EThread1);
fp=func1;
retval = ThreadCreate(&lThreadData, (void*) EThread2);
retval = ThreadDestroy(&lThreadData, (void*) EThread1);
retval = ThreadDestroy(&lThreadData, (void*) EThread2);
retval = MutexDestroy(&lThreadData);
retval = CondDestroy(&lThreadData);
StopThread(&lThreadData);
err = pthread_cond_destroy(&l_staticcondvar);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutex_destroy(&l_recursivemutex);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutex_destroy(&l_errorcheckmutex);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutex_destroy(&l_staticmutex);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutexattr_destroy(&recursiveattr);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutexattr_destroy(&errorcheckattr);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutexattr_destroy(&defaultattr);
if(err != EINVAL)
{
errsum += err;
}
err = sem_destroy(&lSignalSemaphore);
if(err != EINVAL)
{
errsum += err;
}
err = sem_destroy(&lSuspendSemaphore);
if(err != EINVAL)
{
errsum += err;
}
return retval+errsum;
}
HAWThread::~HAWThread()
{
ThreadDestroy(tid_ , 0 , 0);
}
virtual ~LuaNetworkThread()
{
ThreadDestroy();
}
int CLvRtspClient::ThreadOpen( const sqbind::stdString &sUrl, int bVideo, int bAudio, sqbind::CSqMulti *m )
{_STT();
// Lose old container
ThreadDestroy();
// Did we get a valid string?
if ( !sUrl.length() )
return 0;
// Setup usage environment
TaskScheduler* scheduler = BasicTaskScheduler::createNew();
if ( !scheduler )
{ setLastError( -1, sqbind::oex2std( oexMks( oexT( "BasicTaskScheduler::createNew() failed : " ), m_pEnv->getResultMsg() ) ) );
return 0;
} // end if
m_pEnv = BasicUsageEnvironment::createNew( *scheduler );
if ( !m_pEnv )
{ setLastError( -2, sqbind::oex2std( oexMks( oexT( "BasicUsageEnvironment::createNew() failed : " ), m_pEnv->getResultMsg() ) ) );
return 0;
} // end if
#if defined( oexDEBUG )
int nVerbosity = 1;
#else
int nVerbosity = 0;
#endif
// Create rtsp client
m_pRtspClient = RTSPClient::createNew( *m_pEnv, nVerbosity, "CLvRtspClient", m_nTunnelOverHTTPPort );
if ( !m_pRtspClient )
{ setLastError( -3, sqbind::oex2std( oexMks( oexT( "RTSPClient::createNew() failed : " ), m_pEnv->getResultMsg() ) ) );
return 0;
} // end if
char *pOptions = oexNULL;
if ( m_bBlindLogin && m && m->isset( oexT( "username" ) ) )
pOptions = m_pRtspClient->sendOptionsCmd( oexStrToMbPtr( sUrl.c_str() ),
(char*)oexStrToMbPtr( (*m)[ oexT( "username" ) ].str().c_str() ),
(char*)oexStrToMbPtr( (*m)[ oexT( "password" ) ].str().c_str() ) );
else
pOptions = m_pRtspClient->sendOptionsCmd( oexStrToMbPtr( sUrl.c_str() ), 0, 0 );
if ( !pOptions )
{ setLastError( -4, sqbind::oex2std( oexMks( oexT( "sendOptionsCmd() failed : " ), m_pEnv->getResultMsg() ) ) );
return 0;
} // end if
// Ditch the options
delete [] pOptions;
pOptions = oexNULL;
char *pSdp = oexNULL;
if ( m && m->isset( oexT( "username" ) ) )
pSdp = m_pRtspClient->describeWithPassword( oexStrToMbPtr( sUrl.c_str() ),
oexStrToMbPtr( (*m)[ oexT( "username" ) ].str().c_str() ),
oexStrToMbPtr( (*m)[ oexT( "password" ) ].str().c_str() ) );
else
pSdp = m_pRtspClient->describeURL( oexStrToMbPtr( sUrl.c_str() ) );
if ( !pSdp )
{ setLastError( -5, sqbind::oex2std( oexMks( oexT( "describeURL() failed : " ), m_pEnv->getResultMsg() ) ) );
return 0;
} // end if
// Parse params
m_mSdp.parse( oexMbToStrPtr( pSdp ), oexT( "\r\n" ), oexT( ":" ), 1 );
// Create session
m_pSession = MediaSession::createNew( *m_pEnv, pSdp );
// Ditch the SDP description
delete [] pSdp;
pSdp = oexNULL;
if ( !m_pSession )
{ setLastError( -6, sqbind::oex2std( oexMks( oexT( "MediaSession::createNew() failed : " ), m_pEnv->getResultMsg() ) ) );
return 0;
} // end if
// Find a video stream
MediaSubsessionIterator iter( *m_pSession );
MediaSubsession *pss;
int bFoundVideo = 0, bFoundAudio = 0;
oex::CStr8 sVTag = "video", sATag = "audio";
while ( 0 != ( pss = iter.next() )
&& ( ( bVideo && !bFoundVideo ) || ( bAudio && !bFoundAudio ) ) )
{
if ( bVideo && !bFoundVideo && sVTag == pss->mediumName() )
InitVideo( pss ), bFoundVideo = 1;
else if ( bAudio && !bFoundAudio && sATag == pss->mediumName() )
InitAudio( pss ), bFoundAudio = 1;
} // end while
m_bVideo = bFoundVideo;
m_bAudio = bFoundAudio;
if ( !m_bVideo && !m_bAudio )
{ setLastError( -7, sqbind::oex2std( oexMks( oexT( "No Video or audio : " ), m_pEnv->getResultMsg() ) ) );
return 0;
} // end if
// m_pRtspClient->playMediaSession( *m_pSession, 0, 0, 1.f );
// m_pRtspClient->playMediaSession( *m_pSession, 0, -1.f, 1.f );
return 1;
}
