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);
}
