void Enemy::AI(float x, float y)
{
//SDL_LockMutex(mutex);
//Sem Lock
SDL_SemWait(moveLock);
//std::cout << "AI Lock" << std::endl;
m_dirX = 0;
m_dirY = 0;
if (m_x < x)
{
m_dirX = 1;
}
else if (m_x > x)
{
m_dirX = -1;
}
if (m_y < y)
{
m_dirY = 1;
}
else if (m_y > y)
{
m_dirY = -1;
}
isColliding(x,y);
//SDL_UnlockMutex(mutex);
SDL_SemPost(moveLock);
//std::cout << "AI Unlock" << std::endl;
}
/* Lock the semaphore */
int
SDL_mutexP(SDL_mutex * mutex)
{
#if SDL_THREADS_DISABLED
return 0;
#else
Uint32 this_thread;
if (mutex == NULL) {
SDL_SetError("Passed a NULL mutex");
return -1;
}
this_thread = SDL_ThreadID();
if (mutex->owner == this_thread) {
++mutex->recursive;
} else {
/* The order of operations is important.
We set the locking thread id after we obtain the lock
so unlocks from other threads will fail.
*/
SDL_SemWait(mutex->sem);
mutex->owner = this_thread;
mutex->recursive = 0;
}
return 0;
#endif /* SDL_THREADS_DISABLED */
}
int CLoopFeederSink::ThreadMain(void)
{
while (SDL_SemWait(m_myMsgQueueSemaphore) == 0) {
CMsg* pMsg = m_myMsgQueue.get_message();
if (pMsg != NULL) {
switch (pMsg->get_value()) {
case MSG_NODE_STOP_THREAD:
DoStopSink();
delete pMsg;
return 0;
case MSG_NODE_START:
DoStartSink();
break;
case MSG_NODE_STOP:
DoStopSink();
break;
case MSG_SINK_FRAME:
uint32_t dontcare;
DoWriteFrame((CMediaFrame*)pMsg->get_message(dontcare));
break;
}
delete pMsg;
}
}
return -1;
}
/*
* @brief
*/
void FreeWinding(winding_t *w) {
if (debug)
SDL_SemWait(semaphores.active_windings);
Mem_Free(w);
}
void CCamera::init( CameraType cameraType, float X, float Y, float Z, float AspecRatio, float Angle_of_vision ){
semaphore = SDL_CreateSemaphore( 1 );
SDL_SemWait( semaphore );
this->cameraType = cameraType;
camera_position[0] = X; camera_position[1] = Y; camera_position[2] = Z;
radius = sqrt( camera_position[0] * camera_position[0] + camera_position[1] * camera_position[1] + camera_position[2] * camera_position[2] );
x_eye=0.0; y_eye=0.0; z_eye=0.0;
up_vector[0] = 0.0; up_vector[1] = 0.0; up_vector[2] = 1.0;
axle_vector[0] = 1.0; axle_vector[1] = 0.0; axle_vector[2] = 0.0;
const SDL_VideoInfo* vidInfo = SDL_GetVideoInfo( );
float GW = vidInfo->current_w;
float GH = vidInfo->current_h;
vp_x1 = 0.0; vp_x2 = GW;
vp_y1 = 0.0; vp_y2 = GH;
angle_of_vision = Angle_of_vision;
this->aspecRatio=AspecRatio;
redraw = true;
SDL_SemPost( semaphore );
return;
}
int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout)
{
int retval;
if ( ! sem ) {
SDL_SetError("Passed a NULL semaphore");
return -1;
}
/* Try the easy cases first */
if ( timeout == 0 ) {
return SDL_SemTryWait(sem);
}
if ( timeout == SDL_MUTEX_MAXWAIT ) {
return SDL_SemWait(sem);
}
/* Ack! We have to busy wait... */
timeout += SDL_GetTicks();
do {
retval = SDL_SemTryWait(sem);
if ( retval == 0 ) {
break;
}
SDL_Delay(1);
} while ( SDL_GetTicks() < timeout );
return retval;
}
void CCamera::sidewind( int direction, float amount ) {
SDL_SemWait( semaphore );
switch( direction ) {
case UP :
camera_position[2] += amount;
z_eye += amount;
break;
case DOWN :
camera_position[2] -= amount;
z_eye -= amount;
break;
case LEFT :
camera_position[0] -= amount;
x_eye -= amount;
break;
case RIGHT :
camera_position[0] += amount;
x_eye += amount;
break;
}
redraw = true;
SDL_SemPost( semaphore );
return;
}
void CCamera::init( CameraType cameraType, float X, float Y, float Z, float Width, float Height, float Depth ){
semaphore = SDL_CreateSemaphore( 1 );
SDL_SemWait( semaphore );
this->cameraType = cameraType;
camera_position[0] = X; camera_position[1] = Y; camera_position[2] = Z;
x_eye=0.0; y_eye=0.0; z_eye=0.0;
up_vector[0] = 0.0; up_vector[1] = 0.0; up_vector[2] = 1.0;
axle_vector[0] = 1.0; axle_vector[1] = 0.0; axle_vector[2] = 0.0;
const SDL_VideoInfo* vidInfo = SDL_GetVideoInfo( );
float GW = vidInfo->current_w;
float GH = vidInfo->current_h;
vp_x1 = 0.0; vp_x2 = GW;
vp_y1 = 0.0; vp_y2 = GH;
width = Width;
height = Height;
depth = Depth;
redraw = true;
SDL_SemPost( semaphore );
return;
}
void Sync_Audio::write( const sample_t* in, int remain )
{
while ( remain )
{
int count = buf_size - write_pos;
if ( count > remain )
count = remain;
sample_t* out = buf( write_buf ) + write_pos;
if ( gain != (1L << gain_bits) )
{
register long gain = this->gain;
for ( int n = count; n--; )
*out++ = (*in++ * gain) >> gain_bits;
}
else
{
memcpy( out, in, count * sizeof (sample_t) );
in += count;
}
write_pos += count;
remain -= count;
if ( write_pos >= buf_size )
{
write_pos = 0;
write_buf = (write_buf + 1) % buf_count;
SDL_SemWait( free_sem );
}
}
/* Restart all threads that are waiting on the condition variable */
int SDL_CondBroadcast(SDL_cond *cond)
{
if ( ! cond ) {
SDL_SetError("Passed a NULL condition variable");
return -1;
}
/* If there are waiting threads not already signalled, then
signal the condition and wait for the thread to respond.
*/
SDL_LockMutex(cond->lock);
if ( cond->waiting > cond->signals ) {
int i, num_waiting;
num_waiting = (cond->waiting - cond->signals);
cond->signals = cond->waiting;
for ( i=0; i<num_waiting; ++i ) {
SDL_SemPost(cond->wait_sem);
}
/* Now all released threads are blocked here, waiting for us.
Collect them all (and win fabulous prizes!) :-)
*/
SDL_UnlockMutex(cond->lock);
for ( i=0; i<num_waiting; ++i ) {
SDL_SemWait(cond->wait_done);
}
} else {
SDL_UnlockMutex(cond->lock);
}
return 0;
}
static void
XAUDIO2_WaitDevice(_THIS)
{
if (this->enabled) {
SDL_SemWait(this->hidden->semaphore);
}
}
void SoundSDL::read(u16 * stream, int length)
{
if (!_initialized || length <= 0 || !emulating)
return;
#if !JS
/* since this is running in a different thread, speedup and
* throttle can change at any time; save the value so locks
* stay in sync */
bool lock = (emulating && !speedup) ? true : false;
if (lock)
SDL_SemWait (_semBufferFull);
SDL_mutexP(_mutex);
#endif
_rbuf.read(stream, std::min(static_cast<std::size_t>(length) / 2, _rbuf.used()));
#if !JS
SDL_mutexV(_mutex);
SDL_SemPost (_semBufferEmpty);
#endif
}
int resolverloop(void * data)
{
resolverthread *rt = (resolverthread *)data;
for(;;)
{
SDL_SemWait(resolversem);
SDL_LockMutex(resolvermutex);
if(resolverqueries.empty())
{
SDL_UnlockMutex(resolvermutex);
continue;
}
rt->query = resolverqueries.pop();
rt->starttime = lastmillis;
SDL_UnlockMutex(resolvermutex);
ENetAddress address = { ENET_HOST_ANY, CUBE_SERVINFO_PORT };
enet_address_set_host(&address, rt->query);
SDL_LockMutex(resolvermutex);
resolverresult &rr = resolverresults.add();
rr.query = rt->query;
rr.address = address;
rt->query = NULL;
rt->starttime = 0;
SDL_UnlockMutex(resolvermutex);
};
return 0;
};
void display_put_wait( const char *orig_str )
{
display_put( orig_str );
SDLMod key_mod = SDL_GetModState();
if ( !(key_mod & KMOD_CTRL) )
SDL_SemWait( key_sem );
}
void BXBGJob::Lock()
{
if (!m_bActive)
{
//LOG(LOG_LEVEL_DEBUG,"PAUSE: Background job locked id = %d", GetId());
SDL_SemWait(m_pJobLock);
}
}
/**
* @brief
*/
void FreeNode(node_t *node) {
if (debug) {
SDL_SemWait(semaphores.active_nodes);
}
Mem_Free(node);
}
void RegionViewer::incNumPainted()
{
SDL_SemWait(m_lock);
m_numPainted += 1;
SDL_SemPost(m_lock);
}
int UpdateThread(void *unused) {
while (Main::running) {
if (SDL_SemWait(update_semaphore) == 0) {
Main::Tick();
}
}
return 0;
}
LISPBUILDERSDLGLUE_API int SDLCALL SDL_glue_SDL_WaitUntilBufferFull(void) {
/* Let lispbulder-sdl know to fill the audio buffer */
SDL_mutexP(buffer_fill_lock);
buffer_fill = 1;
SDL_mutexV(buffer_fill_lock);
/* And wait until lispbuilder-sdl has done so */
return SDL_SemWait(audio_buffer_lock);
}
void PSP_PumpEvents(_THIS)
{
int i;
enum PspHprmKeys keys;
enum PspHprmKeys changed;
static enum PspHprmKeys old_keys = 0;
SDL_Keysym sym;
SDL_SemWait(event_sem);
keys = hprm;
SDL_SemPost(event_sem);
/* HPRM Keyboard */
changed = old_keys ^ keys;
old_keys = keys;
if(changed) {
for(i=0; i<sizeof(keymap_psp)/sizeof(keymap_psp[0]); i++) {
if(changed & keymap_psp[i].id) {
sym.scancode = keymap_psp[i].id;
sym.sym = keymap_psp[i].sym;
/* out of date
SDL_PrivateKeyboard((keys & keymap_psp[i].id) ?
SDL_PRESSED : SDL_RELEASED,
&sym);
*/
SDL_SendKeyboardKey((keys & keymap_psp[i].id) ?
SDL_PRESSED : SDL_RELEASED, SDL_GetScancodeFromKey(keymap_psp[i].sym));
}
}
}
#ifdef PSPIRKEYB
if (irkbd_ready) {
unsigned char buffer[255];
int i, length, count;
SIrKeybScanCodeData *scanData;
if(pspIrKeybReadinput(buffer, &length) >= 0) {
if((length % sizeof(SIrKeybScanCodeData)) == 0){
count = length / sizeof(SIrKeybScanCodeData);
for( i=0; i < count; i++ ) {
unsigned char raw, pressed;
scanData=(SIrKeybScanCodeData*) buffer+i;
raw = scanData->raw;
pressed = scanData->pressed;
sym.scancode = raw;
sym.sym = keymap[raw];
/* not tested */
/* SDL_PrivateKeyboard(pressed?SDL_PRESSED:SDL_RELEASED, &sym); */
SDL_SendKeyboardKey((keys & keymap_psp[i].id) ?
SDL_PRESSED : SDL_RELEASED, SDL_GetScancodeFromKey(keymap[raw]);
}
}
}
}
double CDebuggingServer::AquireBreakPointAccess(std::list<CBreakPoint>** breakPoints)
{
int ret;
ret = SDL_SemWait(m_BreakPointsSem);
ENSURE(ret == 0);
(*breakPoints) = &m_BreakPoints;
m_BreakPointsLockID = timer_Time();
return m_BreakPointsLockID;
}
int fs_semaphore_wait(fs_semaphore *semaphore) {
#if defined(USE_PSEM)
return sem_wait(&semaphore->semaphore);
#elif defined(USE_SDL)
return SDL_SemWait(semaphore->semaphore);
#else
#error no thread support
#endif
}
SndDrvTmpl::~SndDrvTmpl() {
// TODO Auto-generated destructor stub
enable = FALSE;
if(RenderSem != NULL) {
SDL_SemWait(RenderSem);
SDL_DestroySemaphore(RenderSem);
RenderSem = NULL;
}
}
void rglGlutPostCommand(rglGlutCommand_f c)
{
command = c;
SDL_SemPost(commandSem);
// SDL_LockMutex(commandMutex);
// SDL_CondSignal(commandCond);
// SDL_UnlockMutex(commandMutex);
SDL_SemWait(commandFinishedSem);
}
void CCamera::setAspecRatio( float AspecRatio ){
SDL_SemWait( semaphore );
aspecRatio = AspecRatio;
SDL_SemPost( semaphore );
return;
}
void CCamera::setRedrawTrue( ){
SDL_SemWait( semaphore );
redraw=true;
SDL_SemPost( semaphore );
return;
}
void NONS_Event::wait(){
#if NONS_SYS_WINDOWS
WaitForSingleObject(this->event,INFINITE);
#elif NONS_SYS_UNIX
while (sem_wait(&this->sem)<0 && errno==EINTR);
#elif NONS_SYS_PSP
SDL_SemWait(this->sem);
#endif
}
void CNetwork_Queue::insert( CPacketData pdata ) {
SDL_SemWait( semaphore );
queue_to_send.push_back( pdata );
SDL_SemPost( semaphore );
return;
}
bool NetworkConnectionMenu::HostingServer(const std::string& port,
const std::string& game_name,
const std::string& password,
bool internet)
{
bool r = false;
int net_port;
connection_state_t conn;
if (!internet)
IndexServer::GetInstance()->SetHiddenServer();
if (internet) {
SDL_SemWait(net_info.lock);
conn = IndexServer::GetInstance()->Connect(Constants::WARMUX_VERSION);
if (conn != CONNECTED) {
DisplayNetError(conn);
msg_box->NewMessage(_("Error: Unable to contact the index server to host a game"), c_red);
goto out;
}
}
conn = Network::ServerStart(port, game_name, password);
if (conn != CONNECTED) {
DisplayNetError(conn);
goto out;
}
r = str2int(port, net_port);
if (false == r) {
DisplayNetError(CONN_BAD_PORT);
goto out;
}
if (internet) {
r = IndexServer::GetInstance()->SendServerStatus(game_name, password != "", net_port);
if (false == r) {
DisplayNetError(CONN_BAD_PORT);
msg_box->NewMessage(Format(_("Error: Your server is not reachable from the internet. Check your firewall configuration: TCP Port %s must accept connections from the outside. If you are not directly connected to the internet, check your router configuration: TCP Port %s must be forwarded on your computer."), port.c_str(), port.c_str()),
c_red);
goto out;
}
}
if (!Network::GetInstance()->IsConnected()) {
msg_box->NewMessage(_("Error: Unable to start the server"), c_red);
goto out;
}
r = true;
out:
if (internet)
SDL_SemPost(net_info.lock);
return r;
}
int CALSAAudioSource::ThreadMain(void)
{
debug_message("alsa start");
while (true) {
int rc;
if (m_source) {
rc = SDL_SemTryWait(m_myMsgQueueSemaphore);
} else {
rc = SDL_SemWait(m_myMsgQueueSemaphore);
}
// semaphore error
if (rc == -1) {
break;
}
// message pending
if (rc == 0) {
CMsg* pMsg = m_myMsgQueue.get_message();
if (pMsg != NULL) {
switch (pMsg->get_value()) {
case MSG_NODE_STOP_THREAD:
DoStopCapture(); // ensure things get cleaned up
delete pMsg;
debug_message("alsa stop thread");
return 0;
case MSG_NODE_START:
DoStartCapture();
break;
case MSG_NODE_STOP:
DoStopCapture();
break;
}
delete pMsg;
}
}
if (m_source) {
try {
//debug_message("processaudio");
ProcessAudio();
}
catch (...) {
error_message("alsa stop capture");
DoStopCapture();
break;
}
}
}
debug_message("alsa thread exit");
return -1;
}