// ----------------------------------------------------------------------------- static void EventHandler(char *pszMsg, void *pUser) { CONNINST *pInst = (CONNINST*)pUser; unsigned int uiLen = strlen (pszMsg); static BOOL bFirstLogin = TRUE; if (pInst->hProxy->pCfg->bVerbose && pInst->hProxy->pCfg->fpLog) { fprintf (pInst->hProxy->pCfg->fpLog, "%03d> %s\n", pInst->hSock, pszMsg); fflush (pInst->hProxy->pCfg->fpLog); } if (bFirstLogin && strncmp (pszMsg, "CONNSTATUS", 10) == 0 && strcmp(pszMsg+11, "CONNECTING")) { pInst->iConnectionStat = (strcmp(pszMsg+11, "ONLINE")==0); UnlockMutex (pInst->connected); bFirstLogin = FALSE; } LockMutex(pInst->sendmutex); if (!(SendPacket (pInst, &uiLen, sizeof(uiLen)) && SendPacket (pInst, pszMsg, uiLen))) { //Dispatcher_Stop(pInst); //FreeConnection (pInst); } UnlockMutex(pInst->sendmutex); }
void PlanetOrbitMenu (void) { MENU_STATE MenuState; InputFrameCallback *oldCallback; memset (&MenuState, 0, sizeof MenuState); DrawMenuStateStrings (PM_SCAN, SCAN); LockMutex (GraphicsLock); SetFlashRect (SFR_MENU_3DO); UnlockMutex (GraphicsLock); MenuState.CurState = SCAN; SetMenuSounds (MENU_SOUND_ARROWS, MENU_SOUND_SELECT); oldCallback = SetInputCallback (on_input_frame); MenuState.InputFunc = DoPlanetOrbit; DoInput (&MenuState, TRUE); SetInputCallback (oldCallback); LockMutex (GraphicsLock); SetFlashRect (NULL); UnlockMutex (GraphicsLock); DrawMenuStateStrings (PM_STARMAP, -NAVIGATION); }
void TFB_DrawImage_SetMipmap (TFB_Image *img, TFB_Image *mmimg, int hotx, int hoty) { bool imgpal; bool mmpal; if (!img || !mmimg) return; LockMutex (img->mutex); LockMutex (mmimg->mutex); // Either both images must be using the same colormap, or mipmap image // must not be paletted. This restriction is due to the current // implementation of fill-stamp, which replaces the palette with // fill color. imgpal = TFB_DrawCanvas_IsPaletted (img->NormalImg); mmpal = TFB_DrawCanvas_IsPaletted (mmimg->NormalImg); if (!mmpal || (mmpal && imgpal && img->colormap_index == mmimg->colormap_index)) { img->MipmapImg = mmimg->NormalImg; img->MipmapHs.x = hotx; img->MipmapHs.y = hoty; } else { img->MipmapImg = NULL; } UnlockMutex (mmimg->mutex); UnlockMutex (img->mutex); }
void TFB_DrawImage_CopyRect (TFB_Image *source, const RECT *srcRect, TFB_Image *target, POINT dstPt) { LockMutex (source->mutex); LockMutex (target->mutex); TFB_DrawCanvas_CopyRect (source->NormalImg, srcRect, target->NormalImg, dstPt); target->dirty = TRUE; UnlockMutex (target->mutex); UnlockMutex (source->mutex); }
void arith_frame_blit (FRAME srcFrame, const RECT *rsrc, FRAME dstFrame, const RECT *rdst, int num, int denom) { TFB_Image *srcImg, *dstImg; SDL_Surface *src, *dst; SDL_Rect srcRect, dstRect, *srp = NULL, *drp = NULL; srcImg = srcFrame->image; dstImg = dstFrame->image; LockMutex (srcImg->mutex); LockMutex (dstImg->mutex); src = (SDL_Surface *)srcImg->NormalImg; dst = (SDL_Surface *)dstImg->NormalImg; if (rdst) { dstRect.x = rdst->corner.x; dstRect.y = rdst->corner.y; dstRect.w = rdst->extent.width; dstRect.h = rdst->extent.height; drp = &dstRect; } if (rsrc) { srcRect.x = rsrc->corner.x; srcRect.y = rsrc->corner.y; srcRect.w = rsrc->extent.width; srcRect.h = rsrc->extent.height; srp = &srcRect; } else if (srcFrame->HotSpot.x || srcFrame->HotSpot.y) { if (rdst) { dstRect.x -= srcFrame->HotSpot.x; dstRect.y -= srcFrame->HotSpot.y; } else { dstRect.x = -srcFrame->HotSpot.x; dstRect.y = -srcFrame->HotSpot.y; dstRect.w = GetFrameWidth (srcFrame); dstRect.h = GetFrameHeight (srcFrame); drp = &dstRect; } } TFB_BlitSurface (src, srp, dst, drp, num, denom); UnlockMutex (srcImg->mutex); UnlockMutex (dstImg->mutex); }
BOOLEAN DoSaveTeam (MELEE_STATE *pMS) { STAMP MsgStamp; char file[NAME_MAX]; uio_Stream *stream; CONTEXT OldContext; bool saveOk = false; snprintf (file, sizeof file, "%s.mle", MeleeSetup_getTeamName (pMS->meleeSetup, pMS->side)); LockMutex (GraphicsLock); OldContext = SetContext (ScreenContext); ConfirmSaveLoad (&MsgStamp); // Show the "Saving . . ." message. UnlockMutex (GraphicsLock); stream = uio_fopen (meleeDir, file, "wb"); if (stream != NULL) { saveOk = (MeleeTeam_serialize (&pMS->meleeSetup->teams[pMS->side], stream) == 0); uio_fclose (stream); if (!saveOk) uio_unlink (meleeDir, file); } pMS->load.top = 0; pMS->load.cur = 0; // Undo the screen damage done by the "Saving . . ." message. LockMutex (GraphicsLock); DrawStamp (&MsgStamp); DestroyDrawable (ReleaseDrawable (MsgStamp.frame)); SetContext (OldContext); UnlockMutex (GraphicsLock); if (!saveOk) SaveProblem (); // Update the team list; a previously existing team may have been // deleted when save failed. LoadTeamList (pMS); SelectTeamByFileName (pMS, file); return (stream != 0); }
BOOLEAN TFB_DrawImage_Intersect (TFB_Image *img1, POINT img1org, TFB_Image *img2, POINT img2org, const RECT *interRect) { BOOLEAN ret; LockMutex (img1->mutex); LockMutex (img2->mutex); ret = TFB_DrawCanvas_Intersect (img1->NormalImg, img1org, img2->NormalImg, img2org, interRect); UnlockMutex (img2->mutex); UnlockMutex (img1->mutex); return ret; }
BOOLEAN _ReleaseMusicData (void *data) { TFB_SoundSample **pmus = data; TFB_SoundSample *sample; if (pmus == NULL) return (FALSE); sample = *pmus; assert (sample != 0); if (sample->decoder) { TFB_SoundDecoder *decoder = sample->decoder; LockMutex (soundSource[MUSIC_SOURCE].stream_mutex); if (soundSource[MUSIC_SOURCE].sample == sample) { // Currently playing this sample! Not good. StopStream (MUSIC_SOURCE); } UnlockMutex (soundSource[MUSIC_SOURCE].stream_mutex); sample->decoder = NULL; SoundDecoder_Free (decoder); } TFB_DestroySoundSample (sample); FreeMusicData (data); return (TRUE); }
static void FlushFadeXForms (void) { LockMutex (XFormControl.Lock); finishPendingFade (); UnlockMutex (XFormControl.Lock); }
int GetFadeAmount (void) { int newAmount; LockMutex (XFormControl.Lock); if (fadeInterval) { // have a pending fade TimeCount Now = GetTimeCounter (); sint32 elapsed; elapsed = Now - fadeStartTime; if (elapsed > fadeInterval) elapsed = fadeInterval; newAmount = fadeAmount + (long)fadeDelta * elapsed / fadeInterval; if (elapsed >= fadeInterval) { // fade is over fadeAmount = newAmount; fadeInterval = 0; } } else { // no fade pending, return the current newAmount = fadeAmount; } UnlockMutex (XFormControl.Lock); return newAmount; }
void TFB_ReturnColorMap (TFB_ColorMap *map) { LockMutex (maplock); release_colormap (map); UnlockMutex (maplock); }
static void DrawRestartMenu (BYTE OldState, BYTE NewState, FRAME f) { RECT r; TEXT t; UNICODE buf[64]; LockMutex (GraphicsLock); SetContext (ScreenContext); r.corner.x = r.corner.y = r.extent.width = r.extent.height = 0; SetContextClipRect (&r); r.corner.x = 0; r.corner.y = 0; r.extent.width = SCREEN_WIDTH; r.extent.height = SCREEN_HEIGHT; SetFlashRect (&r, SetAbsFrameIndex (f, NewState + 1)); // Put version number in the corner SetContextFont (TinyFont); t.pStr = buf; t.baseline.x = SCREEN_WIDTH - 3; t.baseline.y = SCREEN_HEIGHT - 2; t.align = ALIGN_RIGHT; t.CharCount = (COUNT)~0; sprintf (buf, "v%d.%d.%d%s", UQM_MAJOR_VERSION, UQM_MINOR_VERSION, UQM_PATCH_VERSION, UQM_EXTRA_VERSION); SetContextForeGroundColor (WHITE_COLOR); font_DrawText (&t); UnlockMutex (GraphicsLock); (void) OldState; /* Satisfying compiler (unused parameter) */ }
void AlienTalkSegue (COUNT wait_track) { // this skips any talk segues that follow an aborted one if ((GLOBAL (CurrentActivity) & CHECK_ABORT) || TalkingFinished) return; if (!pCurInputState->Initialized) { InitSpeechGraphics (); LockMutex (GraphicsLock); SetColorMap (GetColorMapAddress (CommData.AlienColorMap)); SetContext (AnimContext); DrawAlienFrame (NULL, 0, TRUE); UpdateSpeechGraphics (); CommIntroTransition (); UnlockMutex (GraphicsLock); pCurInputState->Initialized = TRUE; PlayMusic (CommData.AlienSong, TRUE, 1); SetMusicVolume (BACKGROUND_VOL); InitCommAnimations (); LastActivity &= ~CHECK_LOAD; } TalkingFinished = TalkSegue (wait_track); if (TalkingFinished) FadeMusic (FOREGROUND_VOL, ONE_SECOND); }
static COUNT DeltaCredit (SIZE delta_credit) { COUNT Credit; Credit = MAKE_WORD ( GET_GAME_STATE (MELNORME_CREDIT0), GET_GAME_STATE (MELNORME_CREDIT1) ); if ((int)delta_credit >= 0 || ((int)(-delta_credit) <= (int)(Credit))) { Credit += delta_credit; SET_GAME_STATE (MELNORME_CREDIT0, LOBYTE (Credit)); SET_GAME_STATE (MELNORME_CREDIT1, HIBYTE (Credit)); LockMutex (GraphicsLock); DrawStatusMessage ((UNICODE *)~0); UnlockMutex (GraphicsLock); } else { NPCPhrase (NEED_MORE_CREDIT0); NPCPhrase (delta_credit + (int)Credit); NPCPhrase (NEED_MORE_CREDIT1); } return (Credit); }
static void post_melnorme_enc (void) { LockMutex (GraphicsLock); DrawStatusMessage (0); UnlockMutex (GraphicsLock); }
void TFB_DrawImage_Delete (TFB_Image *image) { if (image == 0) { log_add (log_Warning, "INTERNAL ERROR: Tried to delete a null image!"); /* Should we die here? */ return; } LockMutex (image->mutex); TFB_DrawCanvas_Delete (image->NormalImg); if (image->ScaledImg) { TFB_DrawCanvas_Delete (image->ScaledImg); image->ScaledImg = 0; } if (image->FilledImg) { TFB_DrawCanvas_Delete (image->FilledImg); image->FilledImg = 0; } UnlockMutex (image->mutex); DestroyMutex (image->mutex); HFree (image); }
static void Imo2sproxy_Exit(IMO2SPROXY *hInst) { IMO2SPROXY_INST *hProxy = (IMO2SPROXY_INST*)hInst; CONNINST *pInst; if (hProxy->pCfg->bVerbose && hProxy->pCfg->fpLog) fprintf (hProxy->pCfg->fpLog, "W32SkypeEmu:Exit()\n"); if (hProxy->hWndDispatch) DestroyWindow (hProxy->hWndDispatch); if (hProxy->dwThreadID) PostThreadMessage (hProxy->dwThreadID, WM_QUIT, 0, 0); LockMutex(hProxy->loopmutex); // Kill 'em all! if (hProxy->hClients) { while (pInst=List_Pop(hProxy->hClients)) { FreeConnection(pInst); free (pInst); } List_Exit (hProxy->hClients); } UnregisterClass ("Imo2SProxyDispatchWindow", GetModuleHandle(NULL)); UnlockMutex(hProxy->loopmutex); ExitMutex(hProxy->loopmutex); free (hProxy); }
static void GiveRadios (RESPONSE_REF R) { if (PLAYER_SAID (R, we_will_transfer_now)) { SET_GAME_STATE (RADIOACTIVES_PROVIDED, 1); NPCPhrase (FUEL_UP0); NPCPhrase (FUEL_UP1); AlienTalkSegue (1); LockMutex (GraphicsLock); //CommData.AlienAmbientArray[2].AnimFlags |= ANIM_DISABLED; // JMS UnlockMutex (GraphicsLock); XFormColorMap (GetColorMapAddress ( SetAbsColorMapIndex (CommData.AlienColorMap, 0) ), ONE_SECOND / 2); AlienTalkSegue ((COUNT)~0); RevealSelf (0); } else { if (PLAYER_SAID (R, what_will_you_give_us)) NPCPhrase (MESSAGE_GARBLED_1); else if (PLAYER_SAID (R, before_radios_we_need_info)) NPCPhrase (MESSAGE_GARBLED_2); Response (we_will_transfer_now, GiveRadios); Response (what_will_you_give_us, GiveRadios); Response (before_radios_we_need_info, GiveRadios); } }
static void FlushFadeXForms (void) { LockMutex (fadeLock); finishPendingFade (); UnlockMutex (fadeLock); }
static void on_input_frame (void) { LockMutex (GraphicsLock); RotatePlanetSphere (TRUE); UnlockMutex (GraphicsLock); }
static void RosterCleanup (MENU_STATE *pMS) { if (pMS->flash_task) { UnlockMutex (GraphicsLock); ConcludeTask (pMS->flash_task); LockMutex (GraphicsLock); pMS->flash_task = 0; } if (pMS->CurFrame) { STAMP s; SHIP_FRAGMENT *StarShipPtr; SetContext (StatusContext); s.origin = pMS->first_item; StarShipPtr = LockShipFrag (&GLOBAL (built_ship_q), (HSHIPFRAG)pMS->CurFrame); s.frame = StarShipPtr->icons; UnlockShipFrag (&GLOBAL (built_ship_q), (HSHIPFRAG)pMS->CurFrame); if (!(pMS->CurState & SHIP_TOGGLE)) DrawStamp (&s); else { SetContextForeGroundColor (WHITE_COLOR); DrawFilledStamp (&s); } } }
static void DrawDevices (DEVICES_STATE *devState, COUNT OldDevice, COUNT NewDevice) { LockMutex (GraphicsLock); BatchGraphics (); SetContext (StatusContext); if (OldDevice > NUM_DEVICES) { // Asked for the initial display or refresh DrawDevicesDisplay (devState); // do not draw unselected again this time OldDevice = NewDevice; } if (OldDevice != NewDevice) { // unselect the previous element DrawDevice (devState->list[OldDevice], OldDevice - devState->topIndex, false); } if (NewDevice < NUM_DEVICES) { // select the new element DrawDevice (devState->list[NewDevice], NewDevice - devState->topIndex, true); } UnbatchGraphics (); UnlockMutex (GraphicsLock); }
void StopTrack (void) { LockMutex (soundSource[SPEECH_SOURCE].stream_mutex); StopStream (SPEECH_SOURCE); track_count = 0; tracks_length = 0; cur_chunk = NULL; cur_sub_chunk = NULL; UnlockMutex (soundSource[SPEECH_SOURCE].stream_mutex); if (chunks_head) { chunks_tail = NULL; destroy_SoundChunk_list (chunks_head); chunks_head = NULL; last_sub = NULL; } if (sound_sample) { // We delete the decoders ourselves sound_sample->decoder = NULL; TFB_DestroySoundSample (sound_sample); sound_sample = NULL; } }
void TFB_DrawImage_Rect (RECT *rect, int r, int g, int b, TFB_Image *image) { LockMutex (image->mutex); TFB_DrawCanvas_Rect (rect, r, g, b, image->NormalImg); image->dirty = TRUE; UnlockMutex (image->mutex); }
// Initialise the surface graphics, and start the planet music. // Called from the GenerateFunctions.generateOribital() function // (when orbit is entered; either from IP, or from loading a saved game) // and when "starmap" is selected from orbit and then cancelled; // also after in-orbit comm and after defeating planet guards in combat. // SurfDefFrame contains surface definition images when a planet comes // with its own bitmap (currently only for Earth) void LoadPlanet (FRAME SurfDefFrame) { bool WaitMode = !(LastActivity & CHECK_LOAD); PLANET_DESC *pPlanetDesc; #ifdef DEBUG if (disableInteractivity) return; #endif assert (pSolarSysState->InOrbit && !pSolarSysState->TopoFrame); CreatePlanetContext (); if (WaitMode) { LockMutex (GraphicsLock); DrawOrbitalDisplay (DRAW_ORBITAL_WAIT); UnlockMutex (GraphicsLock); } StopMusic (); pPlanetDesc = pSolarSysState->pOrbitalDesc; GeneratePlanetSurface (pPlanetDesc, SurfDefFrame); SetPlanetMusic (pPlanetDesc->data_index & ~PLANET_SHIELDED); GeneratePlanetSide (); if (!PLRPlaying ((MUSIC_REF)~0)) PlayMusic (LanderMusic, TRUE, 1); if (WaitMode) { ZoomInPlanetSphere (); LockMutex (GraphicsLock); DrawOrbitalDisplay (DRAW_ORBITAL_UPDATE); UnlockMutex (GraphicsLock); } else { LockMutex (GraphicsLock); DrawOrbitalDisplay (DRAW_ORBITAL_FULL); UnlockMutex (GraphicsLock); } }
void var_unlock (struct varlist *varlist, S4 index) { #if OS_AROS UnlockMutex (varlist[index].mutex); #else pthread_mutex_unlock (&varlist[index].mutex); #endif }
static void unlockQueue (void) { if (!qlock) return; UnlockMutex (qmutex); }
static void runCommAnimFrame (void) { LockMutex (GraphicsLock); UpdateCommGraphics (); UnlockMutex (GraphicsLock); SleepThread (COMM_ANIM_RATE); }
static void regain_lockstep() { // This looks jolly ugly to me - I need to talk to others who are more // experienced in concurrency to see if I can improve it. if (term->sync_even) { UnlockMutex(term->mutex1); LockMutex(term->mutex3); UnlockMutex(term->mutex2); LockMutex(term->mutex4); } else { UnlockMutex(term->mutex3); LockMutex(term->mutex1); UnlockMutex(term->mutex4); LockMutex(term->mutex2); } }
void TFB_DrawImage_Rect (RECT *rect, Color color, DrawMode mode, TFB_Image *target) { LockMutex (target->mutex); TFB_DrawCanvas_Rect (rect, color, mode, target->NormalImg); target->dirty = TRUE; UnlockMutex (target->mutex); }