static void thread_free(void *data) { thread_video_t *thr = (thread_video_t*)data; thread_packet_t pkt = { CMD_FREE }; if (!thr) return; thread_send_and_wait(thr, &pkt); sthread_join(thr->thread); #if defined(HAVE_MENU) free(thr->texture.frame); #endif free(thr->frame.buffer); slock_free(thr->frame.lock); slock_free(thr->lock); scond_free(thr->cond_cmd); scond_free(thr->cond_thread); free(thr->alpha_mod); slock_free(thr->alpha_lock); RARCH_LOG("Threaded video stats: Frames pushed: %u, Frames dropped: %u.\n", thr->hit_count, thr->miss_count); free(thr); }
static void rarch_main_data_thread_init(void) { data_runloop_t *runloop = rarch_main_data_get_ptr(); if (!runloop) return; runloop->lock = slock_new(); runloop->cond_lock = slock_new(); runloop->overlay_lock = slock_new(); runloop->cond = scond_new(); runloop->thread = sthread_create(data_thread_loop, runloop); if (!runloop->thread) goto error; slock_lock(runloop->lock); runloop->thread_inited = true; runloop->alive = true; runloop->thread_code = THREAD_CODE_ALIVE; slock_unlock(runloop->lock); return; error: slock_free(runloop->lock); slock_free(runloop->cond_lock); slock_free(runloop->overlay_lock); scond_free(runloop->cond); }
static void coreaudio_free(void *data) { coreaudio_t *dev = (coreaudio_t*)data; if (!dev) return; if (dev->dev_alive) { AudioOutputUnitStop(dev->dev); #ifdef OSX_PPC CloseComponent(dev->dev); #else AudioComponentInstanceDispose(dev->dev); #endif } if (dev->buffer) fifo_free(dev->buffer); slock_free(dev->lock); scond_free(dev->cond); free(dev); }
void rarch_softfilter_free(rarch_softfilter_t *filt) { unsigned i; i = 0; (void)i; if (!filt) return; free(filt->packets); if (filt->impl && filt->impl_data) filt->impl->destroy(filt->impl_data); #if !defined(HAVE_FILTERS_BUILTIN) && defined(HAVE_DYLIB) if (filt->lib) dylib_close(filt->lib); #endif #ifdef HAVE_THREADS for (i = 0; i < filt->threads; i++) { if (!filt->thread_data[i].thread) continue; slock_lock(filt->thread_data[i].lock); filt->thread_data[i].die = true; scond_signal(filt->thread_data[i].cond); slock_unlock(filt->thread_data[i].lock); sthread_join(filt->thread_data[i].thread); slock_free(filt->thread_data[i].lock); scond_free(filt->thread_data[i].cond); } free(filt->thread_data); #endif free(filt); }
static void sl_free(void *data) { sl_t *sl = (sl_t*)data; if (!sl) return; if (sl->player) SLPlayItf_SetPlayState(sl->player, SL_PLAYSTATE_STOPPED); if (sl->buffer_queue_object) SLObjectItf_Destroy(sl->buffer_queue_object); if (sl->output_mix) SLObjectItf_Destroy(sl->output_mix); if (sl->engine_object) SLObjectItf_Destroy(sl->engine_object); if (sl->lock) slock_free(sl->lock); if (sl->cond) scond_free(sl->cond); free(sl->buffer); free(sl->buffer_chunk); free(sl); }
static void alsa_thread_free(void *data) { alsa_thread_t *alsa = (alsa_thread_t*)data; if (alsa) { if (alsa->worker_thread) { slock_lock(alsa->cond_lock); alsa->thread_dead = true; slock_unlock(alsa->cond_lock); sthread_join(alsa->worker_thread); } if (alsa->buffer) fifo_free(alsa->buffer); if (alsa->cond) scond_free(alsa->cond); if (alsa->fifo_lock) slock_free(alsa->fifo_lock); if (alsa->cond_lock) slock_free(alsa->cond_lock); if (alsa->pcm) { snd_pcm_drop(alsa->pcm); snd_pcm_close(alsa->pcm); } free(alsa); } }
static void ja_free(void *data) { int i; jack_t *jd = (jack_t*)data; jd->shutdown = true; if (jd->client != NULL) { jack_deactivate(jd->client); jack_client_close(jd->client); } for (i = 0; i < 2; i++) if (jd->buffer[i] != NULL) jack_ringbuffer_free(jd->buffer[i]); #ifdef HAVE_THREADS if (jd->cond_lock) slock_free(jd->cond_lock); if (jd->cond) scond_free(jd->cond); #endif free(jd); }
static void dispmanx_gfx_free(void *data) { int i; struct dispmanx_video *_dispvars = data; if (!_dispvars) return; dispmanx_free_main_resources(_dispvars); /* Close display and deinitialize. */ vc_dispmanx_display_close(_dispvars->display); bcm_host_deinit(); /* Destroy mutexes and conditions. */ slock_free(_dispvars->pending_mutex); scond_free(_dispvars->vsync_condition); for (i = 0; i < NUMPAGES; i++) slock_free(_dispvars->pages[i].page_used_mutex); if (_dispvars->pages) free (_dispvars->pages); _dispvars->pages = NULL; dispmanx_unblank_console(_dispvars); }
static void coreaudio_free(void *data) { coreaudio_t *dev = (coreaudio_t*)data; if (!dev) return; if (dev->dev_alive) { AudioOutputUnitStop(dev->dev); #if (defined(__MACH__) && (defined(__ppc__) || defined(__ppc64__))) CloseComponent(dev->dev); #else AudioComponentInstanceDispose(dev->dev); #endif } if (dev->buffer) fifo_free(dev->buffer); slock_free(dev->lock); scond_free(dev->cond); free(dev); }
void ssem_free(ssem_t *semaphore) { if (!semaphore) return; scond_free(semaphore->cond); slock_free(semaphore->mutex); free((void*)semaphore); }
static void rs_free(void *data) { rsd_t *rsd = (rsd_t*)data; rsd_stop(rsd->rd); rsd_free(rsd->rd); fifo_free(rsd->buffer); slock_free(rsd->cond_lock); scond_free(rsd->cond); free(rsd); }
static void sdl_audio_free(void *data) { SDL_CloseAudio(); SDL_QuitSubSystem(SDL_INIT_AUDIO); sdl_audio_t *sdl = (sdl_audio_t*)data; if (sdl) { fifo_free(sdl->buffer); slock_free(sdl->lock); scond_free(sdl->cond); } free(sdl); }
static void thread_free(void *data) { thread_video_t *thr = (thread_video_t*)data; if (!thr) return; thread_send_cmd(thr, CMD_FREE); thread_wait_reply(thr, CMD_FREE); sthread_join(thr->thread); #if defined(HAVE_RGUI) || defined(HAVE_RMENU) free(thr->texture.frame); #endif free(thr->frame.buffer); slock_free(thr->frame.lock); slock_free(thr->lock); scond_free(thr->cond_cmd); scond_free(thr->cond_thread); RARCH_LOG("Threaded video stats: Frames pushed: %u, Frames dropped: %u.\n", thr->hit_count, thr->miss_count); free(thr); }
void autosave_free(autosave_t *handle) { slock_lock(handle->cond_lock); handle->quit = true; slock_unlock(handle->cond_lock); scond_signal(handle->cond); sthread_join(handle->thread); slock_free(handle->lock); slock_free(handle->cond_lock); scond_free(handle->cond); free(handle->buffer); free(handle); }
static void data_runloop_thread_deinit(data_runloop_t *runloop) { if (!runloop->thread_inited) { slock_lock(runloop->cond_lock); runloop->alive = false; scond_signal(runloop->cond); slock_unlock(runloop->cond_lock); sthread_join(runloop->thread); slock_free(runloop->lock); slock_free(runloop->cond_lock); rarch_main_data_overlay_thread_uninit(); scond_free(runloop->cond); } }
static void data_runloop_thread_deinit(void) { if (!g_data_runloop.thread_inited) { slock_lock(g_data_runloop.cond_lock); g_data_runloop.alive = false; scond_signal(g_data_runloop.cond); slock_unlock(g_data_runloop.cond_lock); sthread_join(g_data_runloop.thread); slock_free(g_data_runloop.lock); slock_free(g_data_runloop.cond_lock); rarch_main_data_overlay_thread_uninit(); scond_free(g_data_runloop.cond); } }
CDIF_MT::CDIF_MT(CDAccess *cda) : disc_cdaccess(cda), CDReadThread(NULL), SBMutex(NULL), SBCond(NULL) { try { CDIF_Message msg; RTS_Args s; SBMutex = slock_new(); SBCond = scond_new(); UnrecoverableError = false; s.cdif_ptr = this; CDReadThread = sthread_create((void (*)(void*))ReadThreadStart_C, &s); EmuThreadQueue.Read(&msg); } catch(...) { if(CDReadThread) { sthread_join((sthread_t*)CDReadThread); CDReadThread = NULL; } if(SBMutex) { slock_free((slock_t*)SBMutex); SBMutex = NULL; } if(SBCond) { scond_free((scond_t*)SBCond); SBCond = NULL; } if(disc_cdaccess) { delete disc_cdaccess; disc_cdaccess = NULL; } throw; } }
static void onDestroy(ANativeActivity* activity) { struct android_app* android_app = (struct android_app*)activity->instance; if (!android_app) return; RARCH_LOG("onDestroy: %p\n", activity); sthread_join(android_app->thread); RARCH_LOG("Joined with RetroArch native thread.\n"); close(android_app->msgread); close(android_app->msgwrite); scond_free(android_app->cond); slock_free(android_app->mutex); free(android_app); }
static void retro_task_threaded_deinit(void) { slock_lock(running_lock); worker_continue = false; scond_signal(worker_cond); slock_unlock(running_lock); sthread_join(worker_thread); scond_free(worker_cond); slock_free(running_lock); slock_free(finished_lock); worker_thread = NULL; worker_cond = NULL; running_lock = NULL; finished_lock = NULL; }
static void deinit_thread(ffemu_t *handle) { if (handle->thread) { slock_lock(handle->cond_lock); handle->alive = false; handle->can_sleep = false; slock_unlock(handle->cond_lock); scond_signal(handle->cond); sthread_join(handle->thread); slock_free(handle->lock); slock_free(handle->cond_lock); scond_free(handle->cond); handle->thread = NULL; } }
static void drm_gfx_free(void *data) { struct drm_video *_drmvars = data; if (!_drmvars) return; drm_surface_free(_drmvars, &_drmvars->main_surface); if (_drmvars->menu_surface) drm_surface_free(_drmvars, &_drmvars->menu_surface); /* Destroy mutexes and conditions. */ slock_free(_drmvars->pending_mutex); slock_free(_drmvars->vsync_cond_mutex); scond_free(_drmvars->vsync_condition); free(_drmvars); }
static void dispmanx_gfx_free(void *data) { struct dispmanx_video *_dispvars = data; int i; for (i = MAIN_SURFACE; i <= BACK_SURFACE; i++) { if (_dispvars->surfaces[i].setup) { dispmanx_surface_free(_dispvars, &_dispvars->surfaces[i]); } } /* Close display and deinitialize. */ vc_dispmanx_display_close(_dispvars->display); bcm_host_deinit(); /* Destroy mutexes and conditions. */ slock_free(_dispvars->pending_mutex); slock_free(_dispvars->vsync_cond_mutex); scond_free(_dispvars->vsync_condition); free(_dispvars); }
static void sunxi_gfx_free(void *data) { struct sunxi_video *_dispvars = (struct sunxi_video*)data; /* Stop the vsync thread and wait for it to join. */ /* When menu is active, vsync thread has already been stopped. */ if (!_dispvars->menu_active) { _dispvars->keep_vsync = false; sthread_join(_dispvars->vsync_thread); } slock_free(_dispvars->pending_mutex); scond_free(_dispvars->vsync_condition); free(_dispvars->pages); /* Restore text console contents and reactivate cursor blinking. */ sunxi_restore_console(_dispvars); sunxi_disp_close(_dispvars->sunxi_disp); free(_dispvars); }
static void audio_thread_free(void *data) { audio_thread_t *thr = (audio_thread_t*)data; if (!thr) return; if (thr->thread) { slock_lock(thr->lock); thr->stopped = false; thr->alive = false; scond_signal(thr->cond); slock_unlock(thr->lock); sthread_join(thr->thread); } if (thr->lock) slock_free(thr->lock); if (thr->cond) scond_free(thr->cond); free(thr); }
Task::Impl::~Impl() { shutdown(); slock_free(mutex); scond_free(condWork); }
CDIF_Queue::~CDIF_Queue() { slock_free(ze_mutex); scond_free(ze_cond); }
static void gfx_ctx_vc_destroy(void *data) { vc_ctx_data_t *vc = (vc_ctx_data_t*)data; unsigned i; if (!vc) { g_egl_inited = false; return; } if (vc->egl.dpy) { for (i = 0; i < MAX_EGLIMAGE_TEXTURES; i++) { if (vc->eglBuffer[i] && peglDestroyImageKHR) { eglBindAPI(EGL_OPENVG_API); eglMakeCurrent(vc->egl.dpy, vc->pbuff_surf, vc->pbuff_surf, vc->eglimage_ctx); peglDestroyImageKHR(vc->egl.dpy, vc->eglBuffer[i]); } if (vc->vgimage[i]) { eglBindAPI(EGL_OPENVG_API); eglMakeCurrent(vc->egl.dpy, vc->pbuff_surf, vc->pbuff_surf, vc->eglimage_ctx); vgDestroyImage(vc->vgimage[i]); } } if (vc->egl.ctx) { gfx_ctx_vc_bind_api(data, vc_api, 0, 0); eglMakeCurrent(vc->egl.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); eglDestroyContext(vc->egl.dpy, vc->egl.ctx); } if (vc->egl.hw_ctx) eglDestroyContext(vc->egl.dpy, vc->egl.hw_ctx); if (vc->eglimage_ctx) { eglBindAPI(EGL_OPENVG_API); eglMakeCurrent(vc->egl.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); eglDestroyContext(vc->egl.dpy, vc->eglimage_ctx); } if (vc->egl.surf) { gfx_ctx_vc_bind_api(data, vc_api, 0, 0); eglDestroySurface(vc->egl.dpy, vc->egl.surf); } if (vc->pbuff_surf) { eglBindAPI(EGL_OPENVG_API); eglDestroySurface(vc->egl.dpy, vc->pbuff_surf); } eglBindAPI(EGL_OPENVG_API); eglMakeCurrent(vc->egl.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); gfx_ctx_vc_bind_api(data, vc_api, 0, 0); eglMakeCurrent(vc->egl.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); eglTerminate(vc->egl.dpy); } vc->egl.ctx = NULL; vc->egl.hw_ctx = NULL; vc->eglimage_ctx = NULL; vc->egl.surf = NULL; vc->pbuff_surf = NULL; vc->egl.dpy = NULL; vc->egl.config = 0; g_egl_inited = false; for (i = 0; i < MAX_EGLIMAGE_TEXTURES; i++) { vc->eglBuffer[i] = NULL; vc->vgimage[i] = 0; } /* Stop generating vsync callbacks if we are doing so. * Don't destroy the context while cbs are being generated! */ if (vc->vsync_callback_set) vc_dispmanx_vsync_callback(vc->dispman_display, NULL, NULL); /* Destroy mutexes and conditions. */ slock_free(vc->vsync_condition_mutex); scond_free(vc->vsync_condition); }