/* ljoy_init_joystick: [primary thread]
* Initialise the joystick driver.
*/
static bool ljoy_init_joystick(void)
{
_al_vector_init(&joysticks, sizeof(ALLEGRO_JOYSTICK_LINUX *));
num_joysticks = 0;
if (!(config_mutex = al_create_mutex())) {
return false;
}
// Scan for joysticks
ljoy_scan(false);
ljoy_merge();
#ifdef SUPPORT_HOTPLUG
if (!(hotplug_mutex = al_create_mutex())) {
al_destroy_mutex(config_mutex);
return false;
}
if (!(hotplug_cond = al_create_cond())) {
al_destroy_mutex(config_mutex);
al_destroy_mutex(hotplug_mutex);
return false;
}
if (!(hotplug_thread = al_create_thread(hotplug_proc, NULL))) {
al_destroy_mutex(config_mutex);
al_destroy_mutex(hotplug_mutex);
al_destroy_cond(hotplug_cond);
return false;
}
al_start_thread(hotplug_thread);
inotify_fd = inotify_init();
if (inotify_fd != -1) {
fcntl(inotify_fd, F_SETFL, O_NONBLOCK);
/* Modern Linux probably only needs to monitor /dev/input. */
inotify_add_watch(inotify_fd, "/dev/input", IN_CREATE|IN_DELETE);
_al_unix_start_watching_fd(inotify_fd, ljoy_config_dev_changed, NULL);
ALLEGRO_INFO("Hotplugging enabled\n");
}
else {
ALLEGRO_WARN("Hotplugging not enabled\n");
if (inotify_fd != -1) {
close(inotify_fd);
inotify_fd = -1;
}
}
#endif
return true;
}
/* Function: al_destroy_voice
*/
void al_destroy_voice(ALLEGRO_VOICE *voice)
{
if (voice) {
_al_kcm_unregister_destructor(voice);
al_detach_voice(voice);
ASSERT(al_get_voice_playing(voice) == false);
/* We do NOT lock the voice mutex when calling this method. */
voice->driver->deallocate_voice(voice);
al_destroy_mutex(voice->mutex);
al_destroy_cond(voice->cond);
al_free(voice);
}
}
/* [user thread] */
bool _al_gtk_wait_for_args(GSourceFunc func, void *data)
{
ARGS_BASE *args = (ARGS_BASE *) data;
bool response;
al_lock_mutex(args->mutex);
g_timeout_add(0, func, data);
while (args->done == false) {
al_wait_cond(args->cond, args->mutex);
}
al_unlock_mutex(args->mutex);
response = args->response;
al_destroy_mutex(args->mutex);
al_destroy_cond(args->cond);
return response;
}
static void hapxi_exit_haptic(void)
{
void *ret_value;
ASSERT(hapxi_thread);
ASSERT(hapxi_mutex);
ASSERT(hapxi_cond);
/* Request the event thread to shut down, signal the condition, then join the thread. */
al_set_thread_should_stop(hapxi_thread);
al_signal_cond(hapxi_cond);
al_join_thread(hapxi_thread, &ret_value);
/* clean it all up. */
al_destroy_thread(hapxi_thread);
al_destroy_cond(hapxi_cond);
al_destroy_mutex(hapxi_mutex);
hapxi_mutex = NULL;
}
static void pulseaudio_deallocate_voice(ALLEGRO_VOICE *voice)
{
PULSEAUDIO_VOICE *pv = voice->extra;
al_lock_mutex(voice->mutex);
pv->status = PV_JOIN;
al_broadcast_cond(pv->status_cond);
al_unlock_mutex(voice->mutex);
/* We do NOT hold the voice mutex here, so this does NOT result in a
* deadlock when the thread calls _al_voice_update.
*/
al_join_thread(pv->poll_thread, NULL);
al_destroy_thread(pv->poll_thread);
al_destroy_cond(pv->status_cond);
al_destroy_mutex(pv->buffer_mutex);
pa_simple_free(pv->s);
al_free(pv);
}
/* Function: al_destroy_native_dialog
*/
void al_destroy_native_dialog(ALLEGRO_NATIVE_DIALOG *fd)
{
if (!fd)
return;
if (fd->paths) {
size_t i;
for (i = 0; i < fd->count; i++) {
al_destroy_path(fd->paths[i]);
}
}
_AL_FREE(fd->paths);
if (fd->initial_path)
al_destroy_path(fd->initial_path);
al_ustr_free(fd->title);
al_ustr_free(fd->heading);
al_ustr_free(fd->patterns);
al_ustr_free(fd->text);
al_ustr_free(fd->buttons);
al_destroy_cond(fd->cond);
_AL_FREE(fd);
}
/* Function: al_close_native_text_log
*/
void al_close_native_text_log(ALLEGRO_TEXTLOG *textlog)
{
ALLEGRO_NATIVE_DIALOG *dialog = (ALLEGRO_NATIVE_DIALOG *)textlog;
if (!dialog)
return;
if (!dialog->tl_init_error) {
dialog->tl_done = false;
if (TEXT_LOG_EXTRA_THREAD) {
al_lock_mutex(dialog->tl_text_mutex);
_al_close_native_text_log(dialog);
while (!dialog->tl_done) {
al_wait_cond(dialog->tl_text_cond, dialog->tl_text_mutex);
}
}
else {
_al_close_native_text_log(dialog);
al_lock_mutex(dialog->tl_text_mutex);
}
_al_unregister_destructor(_al_dtor_list, dialog);
}
al_ustr_free(dialog->title);
al_ustr_free(dialog->tl_pending_text);
al_destroy_user_event_source(&dialog->tl_events);
al_unlock_mutex(dialog->tl_text_mutex);
if (TEXT_LOG_EXTRA_THREAD) {
al_destroy_thread(dialog->tl_thread);
}
al_destroy_cond(dialog->tl_text_cond);
al_destroy_mutex(dialog->tl_text_mutex);
al_free(dialog);
}
/* Function: al_create_voice
*/
ALLEGRO_VOICE *al_create_voice(unsigned int freq,
ALLEGRO_AUDIO_DEPTH depth, ALLEGRO_CHANNEL_CONF chan_conf)
{
ALLEGRO_VOICE *voice = NULL;
if (!freq) {
_al_set_error(ALLEGRO_INVALID_PARAM, "Invalid Voice Frequency");
return NULL;
}
voice = al_calloc(1, sizeof(*voice));
if (!voice) {
return NULL;
}
voice->depth = depth;
voice->chan_conf = chan_conf;
voice->frequency = freq;
voice->mutex = al_create_mutex();
voice->cond = al_create_cond();
/* XXX why is this needed? there should only be one active driver */
voice->driver = _al_kcm_driver;
ASSERT(_al_kcm_driver);
if (_al_kcm_driver->allocate_voice(voice) != 0) {
al_destroy_mutex(voice->mutex);
al_destroy_cond(voice->cond);
al_free(voice);
return NULL;
}
_al_kcm_register_destructor("voice", voice,
(void (*)(void *)) al_destroy_voice);
return voice;
}
static bool open_video(ALLEGRO_VIDEO *video)
{
VideoState *is = av_mallocz(sizeof *is);
int i;
AVRational fps;
is->video = video;
init();
video->data = is;
strncpy(is->filename, al_path_cstr(video->filename, '/'),
sizeof(is->filename));
is->av_sync_type = DEFAULT_AV_SYNC_TYPE;
// Open video file
#ifdef FFMPEG_0_8
if (avformat_open_input(&is->format_context, is->filename, NULL,
NULL) != 0) {
#else
if (av_open_input_file(&is->format_context, is->filename, NULL, 0,
NULL) != 0) {
#endif
av_free(is);
return false;
}
if (av_find_stream_info(is->format_context) < 0) {
av_free(is);
return false;
}
is->video_index = -1;
is->audio_index = -1;
for (i = 0; i < (int)is->format_context->nb_streams; i++) {
if (is->format_context->streams[i]->codec->codec_type
== AVMEDIA_TYPE_VIDEO && is->video_index < 0)
{
is->video_index = i;
}
if (is->format_context->streams[i]->codec->codec_type
== AVMEDIA_TYPE_AUDIO && is->audio_index < 0)
{
is->audio_index = i;
}
}
fps = is->format_context->streams[is->video_index]->r_frame_rate;
video->fps = (double)fps.num / fps.den;
video->audio_rate = is->format_context->streams[is->audio_index]->
codec->sample_rate;
video->width = is->format_context->streams[is->video_index]->codec->width;
video->height = is->format_context->streams[is->video_index]->codec->height;
is->pictq_mutex = al_create_mutex();
is->pictq_cond = al_create_cond();
is->timer_mutex = al_create_mutex();
is->timer_cond = al_create_cond();
return true;
}
static bool close_video(ALLEGRO_VIDEO *video)
{
VideoState *is = video->data;
is->quit = true;
if (is->timer_thread) {
al_lock_mutex(is->timer_mutex);
al_signal_cond(is->timer_cond);
al_unlock_mutex(is->timer_mutex);
al_join_thread(is->timer_thread, NULL);
}
if (is->parse_thread) {
al_join_thread(is->parse_thread, NULL);
}
al_destroy_mutex(is->timer_mutex);
al_destroy_cond(is->timer_cond);
av_free(is);
return true;
}
~DATA(){
al_destroy_mutex(mutex);
al_destroy_cond(cond);
}
