/* Destroy all sample instances, and frees the associated vectors. */ static void free_sample_vector(void) { int j; for (j = 0; j < (int) _al_vector_size(&auto_samples); j++) { ALLEGRO_SAMPLE_INSTANCE **slot = _al_vector_ref(&auto_samples, j); al_destroy_sample_instance(*slot); } _al_vector_free(&auto_samples); _al_vector_free(&auto_sample_ids); }
static void wgl_destroy_display(ALLEGRO_DISPLAY *disp) { ALLEGRO_SYSTEM_WIN *system = (ALLEGRO_SYSTEM_WIN *)al_get_system_driver(); ALLEGRO_DISPLAY_WGL *wgl_disp = (ALLEGRO_DISPLAY_WGL *)disp; ALLEGRO_DISPLAY *old_disp = al_get_current_display(); if (old_disp != disp) _al_set_current_display_only(disp); if (system->mouse_grab_display == disp) system->mouse_grab_display = NULL; destroy_display_internals(wgl_disp); _al_event_source_free(&disp->es); _al_vector_find_and_delete(&system->system.displays, &disp); _al_vector_free(&disp->bitmaps); al_free(disp->ogl_extras); if (old_disp != disp) _al_set_current_display_only(old_disp); al_free(disp->vertex_cache); al_free(wgl_disp); }
static void acodec_shutdown(void) { if (acodec_inited) { _al_vector_free(&acodec_table); acodec_inited = false; } }
static void win_shutdown(void) { ALLEGRO_SYSTEM *s; ALLEGRO_DISPLAY_INTERFACE *display_driver; ASSERT(vt); /* Close all open displays. */ s = al_get_system_driver(); while (_al_vector_size(&s->displays) > 0) { ALLEGRO_DISPLAY **dptr = _al_vector_ref(&s->displays, 0); ALLEGRO_DISPLAY *d = *dptr; _al_destroy_display_bitmaps(d); al_destroy_display(d); } _al_vector_free(&s->displays); display_driver = vt->get_display_driver(); if (display_driver && display_driver->shutdown) { display_driver->shutdown(); } _al_win_shutdown_time(); if (using_higher_res_timer) { timeEndPeriod(1); } al_free(vt); vt = NULL; ASSERT(_al_win_system); al_free(_al_win_system); }
static void win_shutdown(void) { ALLEGRO_SYSTEM *s; ASSERT(vt); /* Close all open displays. */ s = al_get_system_driver(); while (_al_vector_size(&s->displays) > 0) { ALLEGRO_DISPLAY **dptr = _al_vector_ref(&s->displays, 0); ALLEGRO_DISPLAY *d = *dptr; al_destroy_display(d); } _al_vector_free(&s->displays); #ifdef ALLEGRO_CFG_D3D _al_d3d_shutdown_display(); #endif _al_win_shutdown_time(); if (using_higher_res_timer) { timeEndPeriod(1); } al_free(vt); vt = NULL; ASSERT(_al_win_system); al_free(_al_win_system); }
/* stream_free: * This function is ALLEGRO_MIXER aware and frees the memory associated with * the sample or mixer, and detaches any attached streams or mixers. */ static void stream_free(ALLEGRO_SAMPLE_INSTANCE *spl) { if (spl) { /* Make sure we free the mixer buffer and de-reference the attached * streams if this is a mixer stream. */ if (spl->is_mixer) { ALLEGRO_MIXER *mixer = (ALLEGRO_MIXER *)spl; int i; _al_kcm_stream_set_mutex(&mixer->ss, NULL); for (i = _al_vector_size(&mixer->streams) - 1; i >= 0; i--) { ALLEGRO_SAMPLE_INSTANCE **slot = _al_vector_ref(&mixer->streams, i); ALLEGRO_SAMPLE_INSTANCE *spl = *slot; spl->parent.u.ptr = NULL; } _al_vector_free(&mixer->streams); if (spl->spl_data.buffer.ptr) { ASSERT(spl->spl_data.free_buf); al_free(spl->spl_data.buffer.ptr); spl->spl_data.buffer.ptr = NULL; } spl->spl_data.free_buf = false; } ASSERT(! spl->spl_data.free_buf); al_free(spl); } }
/* ljoy_exit_joystick: [primary thread] * Shut down the joystick driver. */ static void ljoy_exit_joystick(void) { int i; #ifdef SUPPORT_HOTPLUG if (inotify_fd != -1) { _al_unix_stop_watching_fd(inotify_fd); close(inotify_fd); inotify_fd = -1; } hotplug_ended = true; al_signal_cond(hotplug_cond); al_join_thread(hotplug_thread, NULL); #endif al_destroy_mutex(config_mutex); config_mutex = NULL; for (i = 0; i < (int)_al_vector_size(&joysticks); i++) { ALLEGRO_JOYSTICK_LINUX **slot = _al_vector_ref(&joysticks, i); inactivate_joy(*slot); al_free(*slot); } _al_vector_free(&joysticks); num_joysticks = 0; }
/* Function: al_destroy_path */ void al_destroy_path(ALLEGRO_PATH *path) { unsigned i; if (!path) { return; } if (path->drive) { al_ustr_free(path->drive); path->drive = NULL; } if (path->filename) { al_ustr_free(path->filename); path->filename = NULL; } for (i = 0; i < _al_vector_size(&path->segments); i++) { al_ustr_free(get_segment(path, i)); } _al_vector_free(&path->segments); if (path->basename) { al_ustr_free(path->basename); path->basename = NULL; } if (path->full_string) { al_ustr_free(path->full_string); path->full_string = NULL; } _AL_FREE(path); }
void _al_d3d_destroy_display_format_list(void) { /* Free the display format list */ for (int j = 0; j < (int)_al_vector_size(&eds_list); j++) { void **eds = (void **)_al_vector_ref(&eds_list, j); al_free(*eds); } _al_vector_free(&eds_list); }
void _al_d3d_bmp_destroy(void) { while (!_al_vector_is_empty(&created_bitmaps)) _al_vector_delete_at(&created_bitmaps, _al_vector_size(&created_bitmaps)-1); _al_vector_free(&created_bitmaps); _al_vector_init(&created_bitmaps, sizeof(ALLEGRO_SYSTEM_INTERFACE *)); al_free(vt); vt = NULL; }
/* _al_shutdown_destructors: * Free the list of destructors. The list should be empty now. */ void _al_shutdown_destructors(_AL_DTOR_LIST *dtors) { if (!dtors) { return; } /* free resources used by the destructor subsystem */ ASSERT(_al_vector_size(&dtors->dtors) == 0); _al_vector_free(&dtors->dtors); _al_mutex_destroy(&dtors->mutex); al_free(dtors); }
static void xdpy_destroy_display(ALLEGRO_DISPLAY *d) { ALLEGRO_SYSTEM_XGLX *s = (ALLEGRO_SYSTEM_XGLX *)al_get_system_driver(); ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)d; ALLEGRO_OGL_EXTRAS *ogl = d->ogl_extras; bool is_last; ALLEGRO_DEBUG("destroying display.\n"); /* If we're the last display, convert all bitmaps to display independent * (memory) bitmaps. Otherwise, pass all bitmaps to any other living * display. We assume all displays are compatible.) */ is_last = (s->system.displays._size == 1); if (is_last) convert_display_bitmaps_to_memory_bitmap(d); else transfer_display_bitmaps_to_any_other_display(s, d); _al_ogl_unmanage_extensions(d); ALLEGRO_DEBUG("unmanaged extensions.\n"); _al_mutex_lock(&s->lock); _al_vector_find_and_delete(&s->system.displays, &d); if (ogl->backbuffer) { _al_ogl_destroy_backbuffer(ogl->backbuffer); ogl->backbuffer = NULL; ALLEGRO_DEBUG("destroy backbuffer.\n"); } if (glx->overridable_vt) { glx->overridable_vt->destroy_display_hook(d, is_last); } if (s->mouse_grab_display == d) { s->mouse_grab_display = NULL; } _al_vector_free(&d->bitmaps); _al_event_source_free(&d->es); al_free(d->ogl_extras); al_free(d->vertex_cache); al_free(d); _al_mutex_unlock(&s->lock); ALLEGRO_DEBUG("destroy display finished.\n"); }
/* Function: al_destroy_event_queue */ void al_destroy_event_queue(ALLEGRO_EVENT_QUEUE *queue) { ASSERT(queue); _al_unregister_destructor(_al_dtor_list, queue); /* Unregister any event sources registered with this queue. */ while (_al_vector_is_nonempty(&queue->sources)) { ALLEGRO_EVENT_SOURCE **slot = _al_vector_ref_back(&queue->sources); al_unregister_event_source(queue, *slot); } ASSERT(_al_vector_is_empty(&queue->sources)); _al_vector_free(&queue->sources); ASSERT(queue->events_head == queue->events_tail); _al_vector_free(&queue->events); _al_cond_destroy(&queue->cond); _al_mutex_destroy(&queue->mutex); al_free(queue); }
/* Internal function: _al_event_source_free * Free the resources using by an event source structure. It * automatically unregisters the event source from all the event * queues it is currently registered with. */ void _al_event_source_free(ALLEGRO_EVENT_SOURCE *es) { ALLEGRO_EVENT_SOURCE_REAL *this = (ALLEGRO_EVENT_SOURCE_REAL *)es; /* Unregister from all queues. */ while (!_al_vector_is_empty(&this->queues)) { ALLEGRO_EVENT_QUEUE **slot = _al_vector_ref_back(&this->queues); al_unregister_event_source(*slot, es); } _al_vector_free(&this->queues); _al_mutex_destroy(&this->mutex); }
static void shutdown_system_driver(void) { if (active_sysdrv) { if (active_sysdrv->user_exe_path) al_destroy_path(active_sysdrv->user_exe_path); if (active_sysdrv->vt && active_sysdrv->vt->shutdown_system) active_sysdrv->vt->shutdown_system(); active_sysdrv = NULL; while (!_al_vector_is_empty(&_al_system_interfaces)) _al_vector_delete_at(&_al_system_interfaces, _al_vector_size(&_al_system_interfaces)-1); _al_vector_free(&_al_system_interfaces); _al_vector_init(&_al_system_interfaces, sizeof(ALLEGRO_SYSTEM_INTERFACE *)); } al_destroy_config(sys_config); sys_config = NULL; }
static void xglx_shutdown_system(void) { ALLEGRO_SYSTEM *s = al_get_system_driver(); ALLEGRO_SYSTEM_XGLX *sx = (void *)s; ALLEGRO_INFO("shutting down.\n"); if (sx->x11display) { /* Events thread only runs if we are connected to an X server. */ _al_thread_join(&sx->thread); } /* Close all open displays. */ while (_al_vector_size(&s->displays) > 0) { ALLEGRO_DISPLAY **dptr = _al_vector_ref(&s->displays, 0); ALLEGRO_DISPLAY *d = *dptr; _al_destroy_display_bitmaps(d); al_destroy_display(d); } _al_vector_free(&s->displays); // Makes sure we wait for any commands sent to the X server when destroying the displays. // Should make sure we don't shutdown before modes are restored. if (sx->x11display) { XSync(sx->x11display, False); } _al_xsys_mmon_exit(sx); if (sx->x11display) { XCloseDisplay(sx->x11display); sx->x11display = None; ALLEGRO_DEBUG("xsys: close x11display.\n"); } if (sx->gfxdisplay) { /* XXX for some reason, crashes if both XCloseDisplay calls are made */ /* XCloseDisplay(sx->gfxdisplay); */ sx->gfxdisplay = None; } al_free(sx); }
static void gp2xwiz_destroy_display_fb(ALLEGRO_DISPLAY *d) { ALLEGRO_SYSTEM_GP2XWIZ *s = (void *)al_get_system_driver(); ALLEGRO_DISPLAY_GP2XWIZ_FB *wiz_disp = (void *)d; _al_vector_find_and_delete(&s->system.displays, &d); /* All bitmaps are memory bitmaps, no need to do anything */ _al_vector_free(&d->bitmaps); _al_event_source_free(&d->es); wiz_disp->backbuffer->memory = wiz_disp->screen_mem; al_destroy_bitmap(wiz_disp->backbuffer); al_free(d->vertex_cache); al_free(d); set_gfx_mode = false; }
static void xglx_shutdown_system(void) { ALLEGRO_SYSTEM *s = al_get_system_driver(); ALLEGRO_SYSTEM_XGLX *sx = (void *)s; ALLEGRO_INFO("shutting down.\n"); if (sx->have_xevents_thread) { _al_thread_join(&sx->xevents_thread); sx->have_xevents_thread = false; } /* Close all open displays. */ while (_al_vector_size(&s->displays) > 0) { ALLEGRO_DISPLAY **dptr = _al_vector_ref(&s->displays, 0); ALLEGRO_DISPLAY *d = *dptr; al_destroy_display(d); } _al_vector_free(&s->displays); // Makes sure we wait for any commands sent to the X server when destroying the displays. // Should make sure we don't shutdown before modes are restored. if (sx->x11display) { XSync(sx->x11display, False); } _al_xsys_mmon_exit(sx); if (sx->x11display) { XCloseDisplay(sx->x11display); sx->x11display = None; ALLEGRO_DEBUG("xsys: close x11display.\n"); } if (sx->gfxdisplay) { XCloseDisplay(sx->gfxdisplay); sx->gfxdisplay = None; } al_free(sx); }
/* Function: al_destroy_menu */ void al_destroy_menu(ALLEGRO_MENU *menu) { ALLEGRO_MENU_ITEM **slot; size_t i; ASSERT(menu); if (menu->parent) { /* If the menu is attached to a menu item, then this is equivelant to removing that menu item. */ ALLEGRO_MENU *parent = menu->parent->parent; ASSERT(parent); for (i = 0; i < _al_vector_size(&parent->items); ++i) { slot = _al_vector_ref(&parent->items, i); if (*slot == menu->parent) { al_remove_menu_item(parent, 0 - (int) i); return; } } /* Should never get here. */ ASSERT(false); return; } else if (menu->display && !menu->is_popup_menu) { /* This is an active, top-level menu. */ al_remove_display_menu(menu->display); } /* Destroy each item associated with the menu. */ while (_al_vector_size(&menu->items)) { slot = _al_vector_ref_back(&menu->items); destroy_menu_item(*slot); } _al_vector_free(&menu->items); al_disable_menu_event_source(menu); al_free(menu); }
static void xglx_shutdown_system(void) { /* Close all open displays. */ ALLEGRO_SYSTEM *s = al_get_system_driver(); ALLEGRO_SYSTEM_XGLX *sx = (void *)s; ALLEGRO_INFO("shutting down.\n"); _al_thread_join(&sx->thread); while (_al_vector_size(&s->displays) > 0) { ALLEGRO_DISPLAY **dptr = _al_vector_ref(&s->displays, 0); ALLEGRO_DISPLAY *d = *dptr; _al_destroy_display_bitmaps(d); al_destroy_display(d); } _al_vector_free(&s->displays); _al_xglx_free_mode_infos(sx); #ifdef ALLEGRO_XWINDOWS_WITH_XINERAMA _al_xsys_xinerama_exit(sx); #endif if (sx->x11display) { XCloseDisplay(sx->x11display); sx->x11display = None; } if (sx->gfxdisplay) { /* XXX for some reason, crashes if both XCloseDisplay calls are made */ /* XCloseDisplay(sx->gfxdisplay); */ sx->gfxdisplay = None; } _AL_FREE(sx); }
static void xdpy_destroy_display(ALLEGRO_DISPLAY *d) { ALLEGRO_SYSTEM_XGLX *s = (void *)al_get_system_driver(); ALLEGRO_DISPLAY_XGLX *glx = (void *)d; ALLEGRO_OGL_EXTRAS *ogl = d->ogl_extras; ALLEGRO_DEBUG("destroy display.\n"); /* If we're the last display, convert all bitmpas to display independent * (memory) bitmaps. */ if (s->system.displays._size == 1) { while (d->bitmaps._size > 0) { ALLEGRO_BITMAP **bptr = _al_vector_ref_back(&d->bitmaps); ALLEGRO_BITMAP *b = *bptr; _al_convert_to_memory_bitmap(b); } } else { /* Pass all bitmaps to any other living display. (We assume all displays * are compatible.) */ size_t i; ALLEGRO_DISPLAY **living = NULL; ASSERT(s->system.displays._size > 1); for (i = 0; i < s->system.displays._size; i++) { living = _al_vector_ref(&s->system.displays, i); if (*living != d) break; } for (i = 0; i < d->bitmaps._size; i++) { ALLEGRO_BITMAP **add = _al_vector_alloc_back(&(*living)->bitmaps); ALLEGRO_BITMAP **ref = _al_vector_ref(&d->bitmaps, i); *add = *ref; (*add)->display = *living; } } _al_xglx_unuse_adapter(s, glx->adapter); _al_ogl_unmanage_extensions(d); ALLEGRO_DEBUG("unmanaged extensions.\n"); _al_mutex_lock(&s->lock); _al_vector_find_and_delete(&s->system.displays, &d); XDestroyWindow(s->x11display, glx->window); if (s->mouse_grab_display == d) { s->mouse_grab_display = NULL; } ALLEGRO_DEBUG("destroy window.\n"); if (d->flags & ALLEGRO_FULLSCREEN) { size_t i; ALLEGRO_DISPLAY **living = NULL; bool last_fullscreen = true; /* If any other fullscreen display is still active on the same adapter, * we must not touch the video mode. */ for (i = 0; i < s->system.displays._size; i++) { living = _al_vector_ref(&s->system.displays, i); ALLEGRO_DISPLAY_XGLX *living_glx = (void*)*living; if (*living == d) continue; /* check for fullscreen displays on the same adapter */ if (living_glx->adapter == glx->adapter && al_get_display_flags(*living) & ALLEGRO_FULLSCREEN) { last_fullscreen = false; } } if (last_fullscreen) { ALLEGRO_DEBUG("restore modes.\n"); _al_xglx_restore_video_mode(s, glx->adapter); } else { ALLEGRO_DEBUG("*not* restoring modes.\n"); } } if (ogl->backbuffer) { _al_ogl_destroy_backbuffer(ogl->backbuffer); ogl->backbuffer = NULL; ALLEGRO_DEBUG("destroy backbuffer.\n"); } if (glx->context) { glXDestroyContext(s->gfxdisplay, glx->context); glx->context = NULL; ALLEGRO_DEBUG("destroy context.\n"); } /* XXX quick pre-release hack */ /* In multi-window programs these result in a double-free bugs. */ #if 0 if (glx->fbc) { al_free(glx->fbc); glx->fbc = NULL; XFree(glx->xvinfo); glx->xvinfo = NULL; } else if (glx->xvinfo) { al_free(glx->xvinfo); glx->xvinfo = NULL; } #endif _al_cond_destroy(&glx->mapped); _al_vector_free(&d->bitmaps); _al_event_source_free(&d->es); al_free(d->ogl_extras); al_free(d->vertex_cache); al_free(d); _al_mutex_unlock(&s->lock); ALLEGRO_DEBUG("destroy display finished.\n"); }
void _al_glsl_shutdown_shaders(void) { _al_vector_free(&shaders); al_destroy_mutex(shaders_mutex); shaders_mutex = NULL; }