static void aout_flush_audio(SDL_Aout *aout) { SDL_Aout_Opaque *opaque = aout->opaque; SDL_LockMutex(opaque->wakeup_mutex); SDLTRACE("aout_flush_audio()"); opaque->need_flush = 1; SDL_CondSignal(opaque->wakeup_cond); SDL_UnlockMutex(opaque->wakeup_mutex); }
bool condition::notify_one() { if(SDL_CondSignal(cond_) < 0) { std::cerr << "SDL_CondSignal: " << SDL_GetError() << "\n"; return false; } return true; }
bool condition::notify_one() { if(SDL_CondSignal(cond_) < 0) { ERR_G << "SDL_CondSignal: " << SDL_GetError() << std::endl; return false; } return true; }
/** * @sa Qcommon_Frame */ void SV_Frame (int now, void *data) { Com_ReadFromPipe(); /* change the gametype even if no server is running (e.g. the first time) */ if (sv_dedicated->integer && sv_gametype->modified) { Com_SetGameType(); sv_gametype->modified = false; } if (sv_dedicated->integer) { const char *s; do { s = Sys_ConsoleInput(); if (s) Cbuf_AddText(va("%s\n", s)); } while (s); } /* if server is not active, do nothing */ if (!svs.initialized) { #ifdef DEDICATED_ONLY Com_Printf("Starting next map from the mapcycle\n"); SV_NextMapcycle(); #endif return; } svs.realtime = now; /* keep the random time dependent */ rand(); SV_CheckSpawnSoldiers(); SV_CheckStartMatch(); SV_CheckTimeouts(); if (!sv_threads->integer) SV_RunGameFrame(); else /* signal the game frame thread to wake up */ SDL_CondSignal(svs.gameFrameCond); SV_LogHandleOutput(); /* next map in the cycle */ if (sv->endgame && sv_maxclients->integer > 1) SV_NextMapcycle(); /* send a heartbeat to the master if needed */ Master_Heartbeat(); SV_PingPlayers(); /* server is empty - so shutdown */ if (svs.abandon && svs.killserver) SV_Shutdown("Server disconnected.", false); }
int FE_PushEvent(SDL_Event *ev) { SDL_LockMutex(eventLock); while (SDL_PushEvent(ev) == -1) SDL_CondWait(eventWait, eventLock); SDL_UnlockMutex(eventLock); SDL_CondSignal(eventWait); /* ? wake thread Waiting for event */ return 1; }
/** * Close a client socket. * @param csock * Socket to close. */ void client_socket_close(client_socket_t *csock) { HARD_ASSERT(csock != NULL); SDL_LockMutex(socket_mutex); if (csock->sc != NULL) { socket_destroy(csock->sc); csock->sc = NULL; } abort_thread = 1; /* Poke anyone waiting at a cond */ SDL_CondSignal(input_buffer_cond); SDL_CondSignal(output_buffer_cond); SDL_UnlockMutex(socket_mutex); }
int ThreadPool::threadWrapper(void* param) { ThreadPoolItem* data = (ThreadPoolItem*)param; SDL_mutexP(data->pool->mutex); while(true) { while(data->pool->nextAction == NULL && !data->pool->quitting) SDL_CondWait(data->pool->awakeThread, data->pool->mutex); if(data->pool->quitting) break; data->pool->usedThreads.insert(data); data->pool->availableThreads.erase(data); Action* act = data->pool->nextAction; data->pool->nextAction = NULL; data->headless = data->pool->nextIsHeadless; data->name = data->pool->nextName; data->finished = false; data->working = true; data->pool->nextData = data; SDL_mutexV(data->pool->mutex); SDL_CondSignal(data->pool->threadStartedWork); g_pLogFile->textOut("Running Thread: " + data->name); data->ret = act->handle(); delete act; g_pLogFile->textOut( data->name + " [finished]" ); SDL_mutexP(data->pool->mutex); data->finished = true; SDL_CondSignal(data->pool->threadStatusChanged); if(!data->headless) { // headless means that we just can clean it up right now without waiting SDL_CondSignal(data->finishedSignal); while(data->working) SDL_CondWait(data->readyForNewWork, data->pool->mutex); } else data->working = false; data->pool->usedThreads.erase(data); data->pool->availableThreads.insert(data); SDL_CondSignal(data->pool->threadStatusChanged); //setCurThreadName(""); } SDL_mutexV(data->pool->mutex); return 0; }
void JobQueue::Queue(Job *job) { // push the job onto the queue SDL_LockMutex(m_queueLock); m_queue.push_back(job); SDL_UnlockMutex(m_queueLock); // and tell a waiting runner that there's one available SDL_CondSignal(m_queueWaitCond); }
static void packet_queue_abort(PacketQueue *q) { SDL_LockMutex(q->mutex); q->abort_request = 1; SDL_CondSignal(q->cond); SDL_UnlockMutex(q->mutex); }
static void frame_queue_next(FrameQueue *f) { av_frame_unref(f->queue[f->rindex].frame); if (++f->rindex == f->max_size) f->rindex = 0; SDL_LockMutex(f->mutex); f->size--; SDL_CondSignal(f->cond); SDL_UnlockMutex(f->mutex); }
/* 每次timer到时间会进来(timer到时间发 FF_REFRESH_EVENT,收到 FF_REFRESH_EVENT 会进来) 一个timer只进一次timer就失效了。不过本函数里面会再起一个timer。 从is->pictq拿出一个 VideoPicture 进行显示,然后pictq的读指针向前移动一步 */ void video_refresh_timer(void *userdata) { VideoState *is = (VideoState *)userdata; VideoPicture *vp; double actual_delay, delay, sync_threshold, ref_clock, diff; if (is->video_st) { if (is->pictq_size == 0) { schedule_refresh(is, 1); } else { vp = &is->pictq[is->pictq_rindex]; delay = vp->pts - is->frame_last_pts; /* the pts from last time */ is->frame_last_pts = vp->pts; /* ----------- */ /*音视频同步*/ ref_clock = get_audio_clock(is); diff = vp->pts - ref_clock; if (diff <= -0.015) { delay = 0; } else if (diff >= 0.015) { delay = 2 * delay; } /* ----------- */ if (delay == 0) { count_delay_is_zero++; delay = 0.010; } count_pict++; printf("delay==0 percentage is %lf",(double)count_delay_is_zero/count_pict); schedule_refresh(is, (int)(delay * 1000 + 0.5)); /* show the picture! */ video_display(is); /* update queue for next picture! */ if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE) { is->pictq_rindex = 0; } SDL_LockMutex(is->pictq_mutex); is->pictq_size--; SDL_CondSignal(is->pictq_cond); SDL_UnlockMutex(is->pictq_mutex); } } else { schedule_refresh(is, 100); } }
void SoundSDL::read(u16 * stream, int length) { if (!_initialized || length <= 0 || !emulating) return; SDL_mutexP(_mutex); _rbuf.read(stream, std::min(static_cast<std::size_t>(length) / 2, _rbuf.used())); SDL_CondSignal(_cond); SDL_mutexV(_mutex); }
int fifo_signal(struct fifo *fifo) { ASSERT_FIFO_LOCKED(fifo); #if defined(HAVE_LIBPTHREAD) && !defined(SDL_FIFOS) /* linux multi-process locking */ return pthread_cond_signal(&fifo->cond); #else /* cross platform locking */ return SDL_CondSignal(fifo->cond); #endif }
static void DelayCallback(void *_delay_data) { delay_data_t *delay_data = _delay_data; SDL_LockMutex(delay_data->mutex); delay_data->finished = 1; SDL_CondSignal(delay_data->cond); SDL_UnlockMutex(delay_data->mutex); }
static void aout_set_volume(SDL_Aout *aout, float left_volume, float right_volume) { SDL_Aout_Opaque *opaque = aout->opaque; SDL_LockMutex(opaque->wakeup_mutex); SDLTRACE("aout_flush_audio()"); opaque->left_volume = left_volume; opaque->right_volume = right_volume; opaque->need_set_volume = 1; SDL_CondSignal(opaque->wakeup_cond); SDL_UnlockMutex(opaque->wakeup_mutex); }
static void aout_set_volume(SDL_Aout *aout, float left_volume, float right_volume) { SDL_Aout_Opaque *opaque = aout->opaque; SDL_LockMutex(opaque->wakeup_mutex); ALOGI("aout_set_volume(%f, %f)", left_volume, right_volume); opaque->left_volume = left_volume; opaque->right_volume = right_volume; opaque->need_set_volume = 1; SDL_CondSignal(opaque->wakeup_cond); SDL_UnlockMutex(opaque->wakeup_mutex); }
int FE_PushEvent (SDL_Event * ev) { SDL_LockMutex (eventLock); while (-1 == SDL_PushEvent (ev)) SDL_CondWait (eventWait, eventLock); SDL_UnlockMutex (eventLock); SDL_CondSignal (eventWait); return 1; }
static void aout_pause_audio(SDL_Aout *aout, int pause_on) { SDL_Aout_Opaque *opaque = aout->opaque; SDL_LockMutex(opaque->wakeup_mutex); SDLTRACE("aout_pause_audio(%d)", pause_on); opaque->pause_on = pause_on; if (!pause_on) SDL_CondSignal(opaque->wakeup_cond); SDL_UnlockMutex(opaque->wakeup_mutex); }
int FE_PollEvent(SDL_Event *event) { int val = 0; SDL_LockMutex(eventLock); val = SDL_PollEvent(event); SDL_UnlockMutex(eventLock); if (val > 0) /* ? wakes thread currently pushing event */ SDL_CondSignal(eventWait); return val; }
int fs_condition_signal(fs_condition *condition) { #if defined(USE_PTHREADS) return pthread_cond_signal(&condition->condition); #elif defined(USE_GLIB) g_cond_signal(&condition->condition); return 0; #elif defined(USE_SDL) return SDL_CondSignal(condition->condition); #else #error no thread support #endif }
int pcm_submit() { if (!pcm.buf) return 0; if (pcm.pos < pcm.len) return 1; SDL_LockMutex(sound_mutex); while (!audio_done) SDL_CondWait(sound_cv, sound_mutex); audio_done = 0; pcm.pos = 0; SDL_CondSignal(sound_cv); SDL_UnlockMutex(sound_mutex); return 1; }
ssize_t SDL_AMediaCodec_FakeFifo_dequeueOutputBuffer(SDL_AMediaCodec_FakeFifo *fifo, SDL_AMediaCodecBufferInfo *info, int64_t timeoutUs) { if (fifo->should_abort) return -1; int64_t timeoutMs = (timeoutUs + 999) / 1000; ssize_t dequeue_ret = -1; uint64_t wait_start = SDL_GetTickHR(); int64_t to_wait = timeoutMs; SDL_LockMutex(fifo->mutex); while (!fifo->should_abort) { if (fifo->size > 0) { SDL_AMediaCodec_FakeFrame *fake = &fifo->fakes[fifo->begin]; *info = fake->info; info->flags |= AMEDIACODEC__BUFFER_FLAG_FAKE_FRAME; dequeue_ret = fake->index; FAK_TRACE("%s, [%d]%lld", __func__, fifo->begin, info->presentationTimeUs); fifo->begin = (fifo->begin + 1) % FAKE_BUFFER_QUEUE_SIZE; fifo->size--; SDL_CondSignal(fifo->wakeup_enqueue_cond); break; } SDL_CondWaitTimeout(fifo->wakeup_dequeue_cond, fifo->mutex, to_wait); if (to_wait >= 0) { uint64_t now = SDL_GetTickHR(); if (now < wait_start) { // tick overflow dequeue_ret = -1; break; } else { uint64_t elapsed = now - wait_start; if (elapsed >= timeoutMs) { // timeout dequeue_ret = -1; break; } else { to_wait = timeoutMs - elapsed; } } } } SDL_UnlockMutex(fifo->mutex); if (fifo->should_abort) return -1; return dequeue_ret; }
Job::Handle AsyncJobQueue::Queue(Job *job, JobClient *client) { Job::Handle handle(job, this, client); // push the job onto the queue SDL_LockMutex(m_queueLock); m_queue.push_back(job); SDL_UnlockMutex(m_queueLock); // and tell a waiting runner that there's one available SDL_CondSignal(m_queueWaitCond); return handle; }
void ANDROID_UpdateRectsMT(_THIS, int numrects, SDL_Rect *rects) { SDL_mutexP(videoThread.mutex); while( ! videoThread.threadReady ) SDL_CondWaitTimeout(videoThread.cond2, videoThread.mutex, 1000); videoThread.cmd = CMD_UPDATERECTS; videoThread._this = this; videoThread.execute = 1; SDL_CondSignal(videoThread.cond); while( videoThread.execute ) SDL_CondWaitTimeout(videoThread.cond2, videoThread.mutex, 1000); SDL_mutexV(videoThread.mutex); }
int FE_WaitEvent (SDL_Event * event) { int val = 0; SDL_LockMutex (eventLock); while (0 >= (val = SDL_PollEvent (event))) SDL_CondWait (eventWait, eventLock); SDL_UnlockMutex (eventLock); SDL_CondSignal (eventWait); return val; }
static void aout_opensles_callback(SLAndroidSimpleBufferQueueItf caller, void *pContext) { SDLTRACE("%s\n", __func__); SDL_Aout *aout = pContext; SDL_Aout_Opaque *opaque = aout->opaque; if (opaque) { SDL_LockMutex(opaque->wakeup_mutex); opaque->is_running = true; SDL_CondSignal(opaque->wakeup_cond); SDL_UnlockMutex(opaque->wakeup_mutex); } }
static void aout_close_audio(SDL_Aout *aout) { SDL_Aout_Opaque *opaque = aout->opaque; SDL_LockMutex(opaque->wakeup_mutex); opaque->abort_request = true; SDL_CondSignal(opaque->wakeup_cond); SDL_UnlockMutex(opaque->wakeup_mutex); SDL_WaitThread(opaque->audio_tid, NULL); opaque->audio_tid = NULL; }
/** ** Fill buffer for the sound card. ** ** @see SDL_OpenAudio ** ** @param udata the pointer stored in userdata field of SDL_AudioSpec. ** @param stream pointer to buffer you want to fill with information. ** @param len is length of audio buffer in bytes. */ static void FillAudio(void *, Uint8 *stream, int len) { if (!Audio.Running) return; Assert(len != Audio.Format.size); SDL_memset(stream, 0, len); SDL_LockMutex(Audio.Lock); SDL_MixAudio(stream, Audio.Buffer, len, SDL_MIX_MAXVOLUME); // Signal our FillThread, we can fill the Audio.Buffer again SDL_CondSignal(Audio.Cond); SDL_UnlockMutex(Audio.Lock); }
static void func_set_playback_rate(SDL_Aout *aout, float speed) { if (!aout) return; SDL_Aout_Opaque *opaque = aout->opaque; SDL_LockMutex(opaque->wakeup_mutex); SDLTRACE("%s %f", __func__, (double)speed); opaque->speed = speed; opaque->speed_changed = 1; SDL_CondSignal(opaque->wakeup_cond); SDL_UnlockMutex(opaque->wakeup_mutex); }
/* =============== GLimp_WakeRenderer =============== */ void GLimp_WakeRenderer(void *data) { SDL_LockMutex(smpMutex); { // Should be NULL if we called GLimp_FrontEndSleep() while (smpData) SDL_CondWait(renderCompletedEvent, smpMutex); smpData = data; SDL_CondSignal(renderCommandsEvent); } SDL_UnlockMutex(smpMutex); }