static void WakeWaiters(BuildQueue* queue, int count)
{
if (count > 1)
CondBroadcast(&queue->m_WorkAvailable);
else
CondSignal(&queue->m_WorkAvailable);
}
// Function to fill the table
void fillThread(int c) {
// Transform the lock
CondId cond = (int)c;
tab[0] = 0;
tab[1] = 1;
int i;
int j;
for (i = 2; i < NUM; i++) {
tab[i] = 0;
for (j = (i-1); j > 0; j--) {
tab[i] += tab[j];
}
}
n_printf("Table just filled\n");
// Signal the cond
if (CondSignal(cond) < 0)
n_printf("Error signal condition");
Exit(0);
}
void test2()
{
CondSignal(cond); /*Signalling the waiting thread */
y+=10;
n_printf("\n value of x inside Test2 is %d", y);
Join(tid1);
}
int func1(void* arg)
{
int retval=0;
ThreadData* pData = (ThreadData*) arg;
retval = MutexLock(pData);
retval = CondSignal(pData);
retval = MutexUnlock(pData);
StopThread(pData);
return retval;
}
static void UnparkExpensiveNode(BuildQueue* queue)
{
if (queue->m_ExpensiveWaitCount > 0)
{
NodeState* node = queue->m_ExpensiveWaitList[--queue->m_ExpensiveWaitCount];
CHECK(NodeStateIsQueued(node));
// Really only to avoid tripping up checks in Enqueue()
NodeStateFlagUnqueued(node);
NodeStateFlagInactive(node);
Enqueue(queue, node);
CondSignal(&queue->m_WorkAvailable);
}
}
//---------------------------------------------------------------------------
// CondHandleBroadcast
//
// This function is very similar to CondHandleSignal. But instead of
// waking only one process, it wakes up all the processes waiting on the
// condition variable. For this call to succeed, the calling process must
// have acquired the lock associated with the condition variable. This
// function should be written in such a way that the calling process
// should retain the lock even after call completion.
//
// Note that the process woken up by this call tries to acquire the lock
// associated with the condition variable as soon as it wakes up. Thus,
// for such a process to run, the process invoking CondHandleBroadcast
// must explicitly release the lock after the call completion.
//---------------------------------------------------------------------------
int CondBroadcast(Cond *c) {
if (!c) return SYNC_FAIL;
if (c->lock->pid != GetCurrentPid()) {
dbprintf('s', "CondBroadcast: Proc %d tried to broadcast, but it doesn't own cond %d\n", GetCurrentPid(), (int)(c-conds));
return SYNC_FAIL;
}
while (!AQueueEmpty(&c->waiting)) {
if (CondSignal(c) != SYNC_SUCCESS) {
dbprintf('s', "CondBroadcast: Proc %d failed in signalling cond %d\n", GetCurrentPid(), (int)(c-conds));
return SYNC_FAIL;
}
}
dbprintf('s', "CondBroadcast: Proc %d successful broadcast on cond %d, still needs to release lock\n",
GetCurrentPid(), (int)(c-conds));
return SYNC_SUCCESS;
}
static void *testLoggingThread(void *args)
{
unsigned int i = 0;
char msg[256];
int *threadNum = (int*)(args);
printf("Thread %d fired off\n", threadNum);
MutexLock(&threadCountLock);
++threadCount;
MutexUnlock(&threadCountLock);
MutexLock(&cond_mutex);
while (start_flag == 0) {
CondWait(&start_cond, &cond_mutex);
}
MutexUnlock(&cond_mutex);
printf("Thread %d actually going\n", *threadNum);
for (i=0; i<numLogsPerThread; ++i) {
int bytes = snprintf(msg, sizeof(msg),
"Thread %d, operation %d: reporting for work, SIR!",
*threadNum, i);
append_log_message(msg, bytes);
}
printf("Thread %d finished logging\n", threadNum);
MutexLock(&threadCountLock);
--threadCount;
CondSignal(&threadCountCond);
MutexUnlock(&threadCountLock);
printf("Thread %d exiting\n", threadNum);
free(threadNum);
return 0;
}
TInt CTestCondwait::TestCond413()
{
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 = MutexLock(&lThreadData);
retval = CondSignal(&lThreadData);
retval = MutexUnlock(&lThreadData);
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;
}
int Decoder::decodeFrame(AVFrame *frame, AVSubtitle *sub) {
int got_frame = 0;
do {
int ret = -1;
// 如果处于舍弃状态，则直接返回
if (queue->isAbort()) {
return -1;
}
// 如果当前没有包在等待，获取队列的序列不相同，取出下一阵
if (!packet_pending || queue->serial != pkt_serial) {
AVPacket pkt;
do {
// 队列为空
if (queue->isEmpty()) {
CondSignal(empty_queue_cond);
}
// 获取裸数据
if (queue->get(&pkt, 1, &pkt_serial) < 0) {
return -1;
}
// 刷新数据
if (pkt.data == flush_pkt->data) {
avcodec_flush_buffers(avctx);
finished = 0;
next_pts = start_pts;
next_pts_tb = start_pts_tb;
}
} while (pkt.data == flush_pkt->data || queue->serial != pkt_serial);
av_packet_unref(&this->pkt);
this->pkt_temp = this->pkt_temp = pkt;
packet_pending = 1;
}
// 根据解码器类型判断是音频还是视频
switch (avctx->codec_type) {
case AVMEDIA_TYPE_VIDEO:
// 视频解码
ret = avcodec_decode_video2(avctx, frame, &got_frame, &pkt_temp);
// 解码成功，更新时间戳
if (got_frame) {
if (reorderPts == -1) {
frame->pts = av_frame_get_best_effort_timestamp(frame);
} else if (!reorderPts) {
frame->pts = frame->pkt_dts;
}
}
break;
case AVMEDIA_TYPE_AUDIO:
// 音频解码
ret = avcodec_decode_audio4(avctx, frame, &got_frame, &pkt_temp);
if (got_frame) {
AVRational tb = (AVRational) {1, frame->sample_rate};
// 更新帧时间戳
if (frame->pts != AV_NOPTS_VALUE) {
frame->pts = av_rescale_q(frame->pts, av_codec_get_pkt_timebase(avctx), tb);
} else if (next_pts != AV_NOPTS_VALUE) {
frame->pts = av_rescale_q(next_pts, next_pts_tb, tb);
}
// 更新下一帧时间戳
if (frame->pts != AV_NOPTS_VALUE) {
next_pts = frame->pts + frame->nb_samples;
next_pts_tb = tb;
}
}
break;
}
// 判断是否解码成功
if (ret < 0) {
packet_pending = 0;
} else {
pkt_temp.dts = pkt_temp.pts = AV_NOPTS_VALUE;
if (pkt_temp.data) {
if (avctx->codec_type != AVMEDIA_TYPE_AUDIO) {
ret = pkt_temp.size;
}
pkt_temp.data += ret;
pkt_temp.size -= ret;
if (pkt_temp.size <= 0) {
packet_pending = 0;
}
} else {
if (!got_frame) {
packet_pending = 0;
finished = pkt_serial;
}
}
}
} while (!got_frame && !finished);
return got_frame;
}
int CondHandleBroadcast(cond_t cond) {
if (cond < 0) return SYNC_FAIL;
if (cond >= MAX_CONDS) return SYNC_FAIL;
if (!conds[cond].inuse) return SYNC_FAIL;
return CondSignal(&conds[cond]);
}
