/* Function: al_open_video
*/
ALLEGRO_VIDEO *al_open_video(char const *filename)
{
ALLEGRO_VIDEO *video;
const char *extension = filename + strlen(filename) - 1;
while ((extension >= filename) && (*extension != '.'))
extension--;
video = al_calloc(1, sizeof *video);
video->vtable = find_handler(extension);
if (video->vtable == NULL) {
ALLEGRO_ERROR("No handler for video extension %s - "
"therefore not trying to load %s.\n", extension, filename);
al_free(video);
return NULL;
}
video->filename = al_create_path(filename);
video->playing = true;
if (!video->vtable->open_video(video)) {
ALLEGRO_ERROR("Could not open %s.\n", filename);
al_destroy_path(video->filename);
al_free(video);
return NULL;
}
al_init_user_event_source(&video->es);
video->es_inited = true;
return video;
}
static ALLEGRO_SYSTEM_INTERFACE *_al_system_win_driver(void)
{
if (vt) return vt;
vt = al_calloc(1, sizeof *vt);
vt->initialize = win_initialize;
vt->get_display_driver = win_get_display_driver;
vt->get_keyboard_driver = win_get_keyboard_driver;
vt->get_mouse_driver = win_get_mouse_driver;
vt->get_joystick_driver = win_get_joystick_driver;
vt->get_num_display_modes = win_get_num_display_modes;
vt->get_display_mode = win_get_display_mode;
vt->shutdown_system = win_shutdown;
vt->get_num_video_adapters = win_get_num_video_adapters;
vt->create_mouse_cursor = _al_win_create_mouse_cursor;
vt->destroy_mouse_cursor = _al_win_destroy_mouse_cursor;
vt->get_monitor_info = win_get_monitor_info;
vt->get_cursor_position = win_get_cursor_position;
vt->grab_mouse = win_grab_mouse;
vt->ungrab_mouse = win_ungrab_mouse;
vt->get_path = _al_win_get_path;
vt->inhibit_screensaver = win_inhibit_screensaver;
vt->open_library = win_open_library;
vt->import_symbol = win_import_symbol;
vt->close_library = win_close_library;
return vt;
}
static ALboolean ALflangerState_deviceUpdate(ALflangerState *state, ALCdevice *Device)
{
ALuint maxlen;
ALuint it;
maxlen = fastf2u(AL_FLANGER_MAX_DELAY * 3.0f * Device->Frequency) + 1;
maxlen = NextPowerOf2(maxlen);
if(maxlen != state->BufferLength)
{
void *temp = al_calloc(16, maxlen * sizeof(ALfloat) * 2);
if(!temp) return AL_FALSE;
al_free(state->SampleBuffer[0]);
state->SampleBuffer[0] = temp;
state->SampleBuffer[1] = state->SampleBuffer[0] + maxlen;
state->BufferLength = maxlen;
}
for(it = 0;it < state->BufferLength;it++)
{
state->SampleBuffer[0][it] = 0.0f;
state->SampleBuffer[1][it] = 0.0f;
}
return AL_TRUE;
}
/* Creates a memory bitmap.
*/
static ALLEGRO_BITMAP *_al_create_memory_bitmap(int w, int h)
{
ALLEGRO_BITMAP *bitmap;
int pitch;
int format = al_get_new_bitmap_format();
format = _al_get_real_pixel_format(al_get_current_display(), format);
bitmap = al_calloc(1, sizeof *bitmap);
bitmap->size = sizeof(*bitmap);
pitch = w * al_get_pixel_size(format);
bitmap->vt = NULL;
bitmap->format = format;
bitmap->flags = (al_get_new_bitmap_flags() | ALLEGRO_MEMORY_BITMAP) &
~ALLEGRO_VIDEO_BITMAP;
bitmap->w = w;
bitmap->h = h;
bitmap->pitch = pitch;
bitmap->display = NULL;
bitmap->locked = false;
bitmap->cl = bitmap->ct = 0;
bitmap->cr_excl = w;
bitmap->cb_excl = h;
al_identity_transform(&bitmap->transform);
bitmap->parent = NULL;
bitmap->xofs = bitmap->yofs = 0;
bitmap->memory = al_malloc(pitch * h);
bitmap->preserve_texture = !(al_get_new_bitmap_flags() & ALLEGRO_NO_PRESERVE_TEXTURE);
return bitmap;
}
ALLEGRO_SYSTEM_INTERFACE *_al_get_iphone_system_interface(void)
{
if (vt)
return vt;
vt = al_calloc(1, sizeof *vt);
vt->id = ALLEGRO_SYSTEM_ID_IPHONE;
vt->initialize = iphone_initialize;
vt->get_display_driver = iphone_get_display_driver;
vt->get_keyboard_driver = _al_get_iphone_keyboard_driver;
vt->get_mouse_driver = _al_get_iphone_mouse_driver;
vt->get_touch_input_driver = _al_get_iphone_touch_input_driver;
vt->get_joystick_driver = _al_get_iphone_joystick_driver;
//xglx_vt->get_num_display_modes = _al_xglx_get_num_display_modes;
//xglx_vt->get_display_mode = _al_xglx_get_display_mode;
//xglx_vt->shutdown_system = xglx_shutdown_system;
vt->shutdown_system = iphone_shutdown_system;
vt->get_num_video_adapters = iphone_get_num_video_adapters;
vt->get_monitor_info = iphone_get_monitor_info;
vt->get_cursor_position = iphone_get_cursor_position;
vt->get_path = _al_iphone_get_path;
//xglx_vt->inhibit_screensaver = xglx_inhibit_screensaver;
return vt;
}
/* Internal function to get a reference to this driver. */
ALLEGRO_SYSTEM_INTERFACE *_al_system_xglx_driver(void)
{
if (xglx_vt)
return xglx_vt;
xglx_vt = al_calloc(1, sizeof *xglx_vt);
xglx_vt->initialize = xglx_initialize;
xglx_vt->get_display_driver = xglx_get_display_driver;
xglx_vt->get_keyboard_driver = xglx_get_keyboard_driver;
xglx_vt->get_mouse_driver = xglx_get_mouse_driver;
xglx_vt->get_joystick_driver = xglx_get_joystick_driver;
xglx_vt->get_num_display_modes = xglx_get_num_display_modes;
xglx_vt->get_display_mode = xglx_get_display_mode;
xglx_vt->shutdown_system = xglx_shutdown_system;
xglx_vt->get_num_video_adapters = xglx_get_num_video_adapters;
xglx_vt->get_monitor_info = xglx_get_monitor_info;
xglx_vt->create_mouse_cursor = _al_xwin_create_mouse_cursor;
xglx_vt->destroy_mouse_cursor = _al_xwin_destroy_mouse_cursor;
xglx_vt->get_cursor_position = xglx_get_cursor_position;
xglx_vt->grab_mouse = xglx_grab_mouse;
xglx_vt->ungrab_mouse = xglx_ungrab_mouse;
xglx_vt->get_path = _al_unix_get_path;
xglx_vt->inhibit_screensaver = xglx_inhibit_screensaver;
return xglx_vt;
}
AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
{
ALCcontext *context;
VECTOR(ALeffectslot*) slotvec;
ALsizei cur;
ALenum err;
context = GetContextRef();
if(!context) return;
VECTOR_INIT(slotvec);
if(!(n >= 0))
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
if(!VECTOR_RESERVE(slotvec, n))
SET_ERROR_AND_GOTO(context, AL_OUT_OF_MEMORY, done);
for(cur = 0;cur < n;cur++)
{
ALeffectslot *slot = al_calloc(16, sizeof(ALeffectslot));
err = AL_OUT_OF_MEMORY;
if(!slot || (err=InitEffectSlot(slot)) != AL_NO_ERROR)
{
al_free(slot);
alDeleteAuxiliaryEffectSlots(cur, effectslots);
SET_ERROR_AND_GOTO(context, err, done);
}
err = NewThunkEntry(&slot->id);
if(err == AL_NO_ERROR)
err = InsertUIntMapEntry(&context->EffectSlotMap, slot->id, slot);
if(err != AL_NO_ERROR)
{
FreeThunkEntry(slot->id);
DELETE_OBJ(slot->Params.EffectState);
al_free(slot);
alDeleteAuxiliaryEffectSlots(cur, effectslots);
SET_ERROR_AND_GOTO(context, err, done);
}
aluInitEffectPanning(slot);
VECTOR_PUSH_BACK(slotvec, slot);
effectslots[cur] = slot->id;
}
err = AddEffectSlotArray(context, VECTOR_BEGIN(slotvec), n);
if(err != AL_NO_ERROR)
{
alDeleteAuxiliaryEffectSlots(cur, effectslots);
SET_ERROR_AND_GOTO(context, err, done);
}
done:
VECTOR_DEINIT(slotvec);
ALCcontext_DecRef(context);
}
static ALLEGRO_DISPLAY *iphone_create_display(int w, int h)
{
ALLEGRO_DISPLAY_IPHONE *d = al_calloc(1, sizeof *d);
ALLEGRO_DISPLAY *display = (void*)d;
ALLEGRO_OGL_EXTRAS *ogl = al_calloc(1, sizeof *ogl);
display->ogl_extras = ogl;
display->vt = _al_get_iphone_display_interface();
display->flags = al_get_new_display_flags();
if (display->flags & ALLEGRO_FULLSCREEN_WINDOW) {
_al_iphone_get_screen_size(&w, &h);
}
display->w = w;
display->h = h;
ALLEGRO_SYSTEM_IPHONE *system = (void *)al_get_system_driver();
/* Add ourself to the list of displays. */
ALLEGRO_DISPLAY_IPHONE **add;
add = _al_vector_alloc_back(&system->system.displays);
*add = d;
/* Each display is an event source. */
_al_event_source_init(&display->es);
_al_iphone_update_visuals();
ALLEGRO_EXTRA_DISPLAY_SETTINGS *eds[system->visuals_count];
memcpy(eds, system->visuals, sizeof(*eds) * system->visuals_count);
qsort(eds, system->visuals_count, sizeof(*eds), _al_display_settings_sorter);
ALLEGRO_INFO("Chose visual no. %i\n", eds[0]->index);
memcpy(&display->extra_settings, eds[0], sizeof(ALLEGRO_EXTRA_DISPLAY_SETTINGS));
/* This will add an OpenGL view with an OpenGL context, then return. */
_al_iphone_add_view(display);
_al_iphone_make_view_current();
_al_ogl_manage_extensions(display);
_al_ogl_set_extensions(ogl->extension_api);
setup_gl(display);
display->flags |= ALLEGRO_OPENGL;
return display;
}
static void add_handler(const char *extension, ALLEGRO_VIDEO_INTERFACE *vtable)
{
VideoHandler *v;
if (handlers == NULL) {
handlers = al_calloc(1, sizeof(VideoHandler));
v = handlers;
}
else {
v = handlers;
while (v->next) {
v = v->next;
}
v->next = al_calloc(1, sizeof(VideoHandler));
v = v->next;
}
v->extension = extension;
v->vtable = vtable;
}
/* Create the extension API table */
static ALLEGRO_OGL_EXT_API *create_extension_api_table(void)
{
ALLEGRO_OGL_EXT_API *ret = al_calloc(1, sizeof(ALLEGRO_OGL_EXT_API));
if (!ret) {
return NULL;
}
return ret;
}
/* Create the extension list */
static ALLEGRO_OGL_EXT_LIST *create_extension_list(void)
{
ALLEGRO_OGL_EXT_LIST *ret = al_calloc(1, sizeof(ALLEGRO_OGL_EXT_LIST));
if (!ret) {
return NULL;
}
return ret;
}
void UpdateListenerProps(ALCcontext *context)
{
ALlistener *listener = context->Listener;
struct ALlistenerProps *props;
/* Get an unused proprty container, or allocate a new one as needed. */
props = ATOMIC_LOAD(&listener->FreeList, almemory_order_acquire);
if(!props)
props = al_calloc(16, sizeof(*props));
else
{
struct ALlistenerProps *next;
do {
next = ATOMIC_LOAD(&props->next, almemory_order_relaxed);
} while(ATOMIC_COMPARE_EXCHANGE_WEAK(struct ALlistenerProps*,
&listener->FreeList, &props, next, almemory_order_seq_cst,
almemory_order_acquire) == 0);
}
/* Copy in current property values. */
ATOMIC_STORE(&props->Position[0], listener->Position[0], almemory_order_relaxed);
ATOMIC_STORE(&props->Position[1], listener->Position[1], almemory_order_relaxed);
ATOMIC_STORE(&props->Position[2], listener->Position[2], almemory_order_relaxed);
ATOMIC_STORE(&props->Velocity[0], listener->Velocity[0], almemory_order_relaxed);
ATOMIC_STORE(&props->Velocity[1], listener->Velocity[1], almemory_order_relaxed);
ATOMIC_STORE(&props->Velocity[2], listener->Velocity[2], almemory_order_relaxed);
ATOMIC_STORE(&props->Forward[0], listener->Forward[0], almemory_order_relaxed);
ATOMIC_STORE(&props->Forward[1], listener->Forward[1], almemory_order_relaxed);
ATOMIC_STORE(&props->Forward[2], listener->Forward[2], almemory_order_relaxed);
ATOMIC_STORE(&props->Up[0], listener->Up[0], almemory_order_relaxed);
ATOMIC_STORE(&props->Up[1], listener->Up[1], almemory_order_relaxed);
ATOMIC_STORE(&props->Up[2], listener->Up[2], almemory_order_relaxed);
ATOMIC_STORE(&props->Gain, listener->Gain, almemory_order_relaxed);
ATOMIC_STORE(&props->MetersPerUnit, listener->MetersPerUnit, almemory_order_relaxed);
ATOMIC_STORE(&props->DopplerFactor, context->DopplerFactor, almemory_order_relaxed);
ATOMIC_STORE(&props->DopplerVelocity, context->DopplerVelocity, almemory_order_relaxed);
ATOMIC_STORE(&props->SpeedOfSound, context->SpeedOfSound, almemory_order_relaxed);
ATOMIC_STORE(&props->SourceDistanceModel, context->SourceDistanceModel, almemory_order_relaxed);
ATOMIC_STORE(&props->DistanceModel, context->DistanceModel, almemory_order_relaxed);
/* Set the new container for updating internal parameters. */
props = ATOMIC_EXCHANGE(struct ALlistenerProps*, &listener->Update, props, almemory_order_acq_rel);
if(props)
{
/* If there was an unused update container, put it back in the
* freelist.
*/
ATOMIC_REPLACE_HEAD(struct ALlistenerProps*, &listener->FreeList, props);
}
}
static ALLEGRO_DISPLAY* wgl_create_display(int w, int h)
{
ALLEGRO_SYSTEM_WIN *system = (ALLEGRO_SYSTEM_WIN *)al_get_system_driver();
ALLEGRO_DISPLAY_WGL **add;
ALLEGRO_DISPLAY_WGL *wgl_display = al_calloc(1, sizeof *wgl_display);
ALLEGRO_DISPLAY *ogl_display = (void*)wgl_display;
ALLEGRO_DISPLAY *display = (void*)ogl_display;
ALLEGRO_DISPLAY_WIN *win_disp = (ALLEGRO_DISPLAY_WIN *)display;
win_disp->adapter = _al_win_determine_adapter();
display->w = w;
display->h = h;
display->refresh_rate = al_get_new_display_refresh_rate();
display->flags = al_get_new_display_flags();
display->vt = &vt;
display->ogl_extras = al_calloc(1, sizeof(ALLEGRO_OGL_EXTRAS));
if (!create_display_internals(wgl_display)) {
al_free(display->ogl_extras);
al_free(display);
return NULL;
}
/* Print out OpenGL version info */
ALLEGRO_INFO("OpenGL Version: %s\n", (const char*)glGetString(GL_VERSION));
ALLEGRO_INFO("Vendor: %s\n", (const char*)glGetString(GL_VENDOR));
ALLEGRO_INFO("Renderer: %s\n\n", (const char*)glGetString(GL_RENDERER));
/* Add ourself to the list of displays. */
add = _al_vector_alloc_back(&system->system.displays);
*add = wgl_display;
/* Each display is an event source. */
_al_event_source_init(&display->es);
_al_win_set_system_mouse_cursor(display, ALLEGRO_SYSTEM_MOUSE_CURSOR_ARROW);
_al_win_show_mouse_cursor(display);
return display;
}
void *
xcalloc (size_t count, size_t n)
{
if (n * count == 0) return NULL;
void *ptr = al_calloc (count, n);
if (! ptr)
error (-1, 0, "%s (%u, %u): cannot allocate memory", __func__,
(unsigned int) count,
(unsigned int) n);
return ptr;
}
ALLEGRO_DISPLAY_INTERFACE *_al_sdl_display_driver(void)
{
if (vt)
return vt;
vt = al_calloc(1, sizeof *vt);
vt->id = AL_ID('S', 'D', 'L', '2');
vt->create_display = sdl_create_display;
vt->destroy_display = sdl_destroy_display;
vt->set_current_display = sdl_set_current_display;
vt->unset_current_display = sdl_unset_current_display;
//vt->clear = GL
//vt->draw_pixel = GL
vt->flip_display = sdl_flip_display;
vt->update_display_region = sdl_update_display_region;
vt->acknowledge_resize = sdl_acknowledge_resize;
vt->resize_display = sdl_resize_display;
/*vt->quick_size = sdl_quick_size;
vt->get_orientation = sdl_get_orientation;*/
vt->create_bitmap = _al_ogl_create_bitmap;
vt->set_target_bitmap = _al_ogl_set_target_bitmap;
vt->get_backbuffer = _al_ogl_get_backbuffer;
vt->is_compatible_bitmap = sdl_is_compatible_bitmap;
/*vt->switch_out = sdl_switch_out;
vt->switch_in = sdl_switch_in;
vt->draw_memory_bitmap_region = sdl_draw_memory_bitmap_region;
vt->wait_for_vsync = sdl_wait_for_vsync;*/
vt->set_mouse_cursor = sdl_set_mouse_cursor;
vt->set_system_mouse_cursor = sdl_set_system_mouse_cursor;
vt->show_mouse_cursor = sdl_show_mouse_cursor;
vt->hide_mouse_cursor = sdl_hide_mouse_cursor;
/*vt->set_icons = sdl_set_icons;*/
vt->set_window_position = sdl_set_window_position;
vt->get_window_position = sdl_get_window_position;
/*vt->set_window_constraints = sdl_set_window_constraints;
vt->get_window_constraints = sdl_get_window_constraints;
vt->set_display_flag = sdl_set_display_flag;*/
vt->set_window_title = sdl_set_window_title;
//vt->flush_vertex_cache = GL
//vt->prepare_vertex_cache = GL
//vt->update_transformation = GL
//vt->set_projection = GL
/*vt->shutdown = sdl_shutdown;
vt->acknowledge_drawing_halt = sdl_acknowledge_drawing_halt;
vt->acknowledge_drawing_resume = sdl_acknowledge_drawing_resume;
vt->set_display_option = sdl_set_display_option;*/
//vt->clear_depth_buffer = GL
vt->update_render_state = _al_ogl_update_render_state;
_al_ogl_add_drawing_functions(vt);
return vt;
}
static int pulseaudio_allocate_recorder(ALLEGRO_AUDIO_RECORDER *r)
{
PULSEAUDIO_RECORDER *pa;
pa = al_calloc(1, sizeof(*pa));
if (!pa) {
ALLEGRO_ERROR("Unable to allocate memory for PULSEAUDIO_RECORDER.\n");
return 1;
}
pa->ss.channels = al_get_channel_count(r->chan_conf);
pa->ss.rate = r->frequency;
if (r->depth == ALLEGRO_AUDIO_DEPTH_UINT8)
pa->ss.format = PA_SAMPLE_U8;
else if (r->depth == ALLEGRO_AUDIO_DEPTH_INT16)
pa->ss.format = PA_SAMPLE_S16NE;
#if PA_API_VERSION > 11
else if (r->depth == ALLEGRO_AUDIO_DEPTH_INT24)
pa->ss.format = PA_SAMPLE_S24NE;
#endif
else if (r->depth == ALLEGRO_AUDIO_DEPTH_FLOAT32)
pa->ss.format = PA_SAMPLE_FLOAT32NE;
else {
ALLEGRO_ERROR("Unsupported PulseAudio sound format (depth).\n");
al_free(pa);
return 1;
}
/* maximum length of the PulseAudio buffer. -1 => let the server decide. */
pa->ba.maxlength = -1;
/* fragment size (bytes) controls how much data is returned back per read.
The documentation recommends -1 for default behavior, but that sets a
latency of around 2 seconds. Lower value decreases latency but increases
overhead.
The following attempts to set it (the base latency) to 1/8 of a second.
*/
pa->ba.fragsize = (r->sample_size * r->frequency) / 8;
pa->s = pa_simple_new(NULL, al_get_app_name(), PA_STREAM_RECORD, NULL, "Allegro Audio Recorder", &pa->ss, NULL, &pa->ba, NULL);
if (!pa->s) {
ALLEGRO_ERROR("pa_simple_new() failed.\n");
al_free(pa);
return 1;
}
r->thread = al_create_thread(pulse_audio_update_recorder, r);
r->extra = pa;
return 0;
};
AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
{
ALCcontext *Context;
ALsizei cur = 0;
Context = GetContextRef();
if(!Context) return;
al_try
{
ALenum err;
CHECK_VALUE(Context, n >= 0);
for(cur = 0;cur < n;cur++)
{
ALeffectslot *slot = al_calloc(16, sizeof(ALeffectslot));
err = AL_OUT_OF_MEMORY;
if(!slot || (err=InitEffectSlot(slot)) != AL_NO_ERROR)
{
al_free(slot);
al_throwerr(Context, err);
break;
}
err = NewThunkEntry(&slot->id);
if(err == AL_NO_ERROR)
err = InsertUIntMapEntry(&Context->EffectSlotMap, slot->id, slot);
if(err != AL_NO_ERROR)
{
FreeThunkEntry(slot->id);
ALeffectState_Destroy(slot->EffectState);
al_free(slot);
al_throwerr(Context, err);
}
effectslots[cur] = slot->id;
}
err = AddEffectSlotArray(Context, n, effectslots);
if(err != AL_NO_ERROR)
al_throwerr(Context, err);
}
al_catchany()
{
if(cur > 0)
alDeleteAuxiliaryEffectSlots(cur, effectslots);
}
al_endtry;
ALCcontext_DecRef(Context);
}
AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
{
ALCcontext *context;
ALeffectslot *first, *last;
ALsizei cur;
ALenum err;
context = GetContextRef();
if(!context) return;
if(!(n >= 0))
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
first = last = NULL;
for(cur = 0;cur < n;cur++)
{
ALeffectslot *slot = al_calloc(16, sizeof(ALeffectslot));
err = AL_OUT_OF_MEMORY;
if(!slot || (err=InitEffectSlot(slot)) != AL_NO_ERROR)
{
al_free(slot);
alDeleteAuxiliaryEffectSlots(cur, effectslots);
SET_ERROR_AND_GOTO(context, err, done);
}
err = NewThunkEntry(&slot->id);
if(err == AL_NO_ERROR)
err = InsertUIntMapEntry(&context->EffectSlotMap, slot->id, slot);
if(err != AL_NO_ERROR)
{
FreeThunkEntry(slot->id);
DELETE_OBJ(slot->Params.EffectState);
al_free(slot);
alDeleteAuxiliaryEffectSlots(cur, effectslots);
SET_ERROR_AND_GOTO(context, err, done);
}
aluInitEffectPanning(slot);
if(!first) first = slot;
if(last) ATOMIC_STORE(&last->next, slot);
last = slot;
effectslots[cur] = slot->id;
}
AddEffectSlotList(context, first, last);
done:
ALCcontext_DecRef(context);
}
void UpdateEffectSlotProps(ALeffectslot *slot, ALboolean withstate)
{
struct ALeffectslotProps *props;
ALeffectState *oldstate;
/* Get an unused property container, or allocate a new one as needed. */
props = ATOMIC_LOAD(&slot->FreeList, almemory_order_acquire);
if(!props)
props = al_calloc(16, sizeof(*props));
else
{
struct ALeffectslotProps *next;
do {
next = ATOMIC_LOAD(&props->next, almemory_order_relaxed);
} while(ATOMIC_COMPARE_EXCHANGE_WEAK(struct ALeffectslotProps*,
&slot->FreeList, &props, next, almemory_order_seq_cst,
almemory_order_consume) == 0);
}
/* Copy in current property values. */
ATOMIC_STORE(&props->Gain, slot->Gain, almemory_order_relaxed);
ATOMIC_STORE(&props->AuxSendAuto, slot->AuxSendAuto, almemory_order_relaxed);
ATOMIC_STORE(&props->Type, slot->Effect.Type, almemory_order_relaxed);
memcpy(&props->Props, &slot->Effect.Props, sizeof(props->Props));
/* Swap out any stale effect state object there may be in the container, to
* delete it.
*/
ATOMIC_STORE(&props->UpdateState, withstate, almemory_order_relaxed);
oldstate = ATOMIC_EXCHANGE(ALeffectState*, &props->State,
withstate ? slot->Effect.State : NULL, almemory_order_relaxed
);
/* Set the new container for updating internal parameters. */
props = ATOMIC_EXCHANGE(struct ALeffectslotProps*, &slot->Update, props,
almemory_order_acq_rel);
if(props)
{
/* If there was an unused update container, put it back in the
* freelist.
*/
struct ALeffectslotProps *first = ATOMIC_LOAD(&slot->FreeList);
do {
ATOMIC_STORE(&props->next, first, almemory_order_relaxed);
} while(ATOMIC_COMPARE_EXCHANGE_WEAK(struct ALeffectslotProps*,
&slot->FreeList, &first, props) == 0);
}
DELETE_OBJ(oldstate);
}
/* Function: al_open_native_text_log
*/
ALLEGRO_TEXTLOG *al_open_native_text_log(char const *title, int flags)
{
ALLEGRO_NATIVE_DIALOG *textlog = NULL;
/* Avoid warnings when log windows are unimplemented. */
(void)title;
(void)flags;
textlog = al_calloc(1, sizeof *textlog);
textlog->title = al_ustr_new(title);
textlog->flags = flags;
if (TEXT_LOG_EXTRA_THREAD) {
textlog->tl_thread = al_create_thread(text_log_thread_proc, textlog);
}
textlog->tl_text_cond = al_create_cond();
textlog->tl_text_mutex = al_create_mutex();
textlog->tl_pending_text = al_ustr_new("");
al_init_user_event_source(&textlog->tl_events);
textlog->tl_init_error = false;
textlog->tl_done = false;
if (TEXT_LOG_EXTRA_THREAD) {
/* Unlike the other dialogs, this one never blocks as the intended
* use case is a log window running in the background for debugging
* purposes when no console can be used. Therefore we have it run
* in a separate thread.
*/
al_start_thread(textlog->tl_thread);
al_lock_mutex(textlog->tl_text_mutex);
while (!textlog->tl_done && !textlog->tl_init_error) {
al_wait_cond(textlog->tl_text_cond, textlog->tl_text_mutex);
}
al_unlock_mutex(textlog->tl_text_mutex);
}
else {
textlog->tl_init_error = !_al_open_native_text_log(textlog);
}
if (textlog->tl_init_error) {
al_close_native_text_log((ALLEGRO_TEXTLOG *)textlog);
return NULL;
}
_al_register_destructor(_al_dtor_list, textlog,
(void (*)(void *))al_close_native_text_log);
return (ALLEGRO_TEXTLOG *)textlog;
}
ALenum NewThunkEntry(ALuint *index)
{
void *NewList;
ALuint i;
ReadLock(&ThunkLock);
for(i = 0;i < ThunkArraySize;i++)
{
if(ATOMIC_EXCHANGE(ALenum, &ThunkArray[i], AL_TRUE, almemory_order_acq_rel) == AL_FALSE)
{
ReadUnlock(&ThunkLock);
*index = i+1;
return AL_NO_ERROR;
}
}
ReadUnlock(&ThunkLock);
WriteLock(&ThunkLock);
/* Double-check that there's still no free entries, in case another
* invocation just came through and increased the size of the array.
*/
for(;i < ThunkArraySize;i++)
{
if(ATOMIC_EXCHANGE(ALenum, &ThunkArray[i], AL_TRUE, almemory_order_acq_rel) == AL_FALSE)
{
WriteUnlock(&ThunkLock);
*index = i+1;
return AL_NO_ERROR;
}
}
NewList = al_calloc(16, ThunkArraySize*2 * sizeof(*ThunkArray));
if(!NewList)
{
WriteUnlock(&ThunkLock);
ERR("Realloc failed to increase to %u entries!\n", ThunkArraySize*2);
return AL_OUT_OF_MEMORY;
}
memcpy(NewList, ThunkArray, ThunkArraySize*sizeof(*ThunkArray));
al_free(ThunkArray);
ThunkArray = NewList;
ThunkArraySize *= 2;
ATOMIC_STORE_SEQ(&ThunkArray[i], AL_TRUE);
WriteUnlock(&ThunkLock);
*index = i+1;
return AL_NO_ERROR;
}
FONT *load_font(char const *name, RGB *pal, void *param){
FONT *f = al_calloc(1, sizeof *f);
int len = strlen(name);
if (len >= 4 && !strcmp(name + len - 4, ".dat")){
DATAFILE *dat = load_datafile(name);
FONT *df = dat->dat;
f->data = df->data;
}
if (!f->is_color) {
FONT *u = upgrade_to_color(f);
*f = *u;
}
return f;
}
/* Function: al_create_menu
*/
ALLEGRO_MENU *al_create_menu(void)
{
ALLEGRO_MENU *m = al_calloc(1, sizeof(*m));
if (m) {
_al_vector_init(&m->items, sizeof(ALLEGRO_MENU_ITEM*));
/* Make sure the platform actually supports menus */
if (!_al_init_menu(m)) {
al_destroy_menu(m);
m = NULL;
}
}
return m;
}
/* Function: al_create_sub_bitmap
*/
ALLEGRO_BITMAP *al_create_sub_bitmap(ALLEGRO_BITMAP *parent,
int x, int y, int w, int h)
{
ALLEGRO_BITMAP *bitmap;
if (parent->parent) {
x += parent->xofs;
y += parent->yofs;
parent = parent->parent;
}
if (parent->display && parent->display->vt &&
parent->display->vt->create_sub_bitmap)
{
bitmap = parent->display->vt->create_sub_bitmap(
parent->display, parent, x, y, w, h);
}
else {
bitmap = al_calloc(1, sizeof *bitmap);
bitmap->size = sizeof *bitmap;
bitmap->vt = parent->vt;
}
bitmap->format = parent->format;
bitmap->flags = parent->flags;
bitmap->w = w;
bitmap->h = h;
bitmap->display = parent->display;
bitmap->locked = false;
bitmap->cl = bitmap->ct = 0;
bitmap->cr_excl = w;
bitmap->cb_excl = h;
al_identity_transform(&bitmap->transform);
bitmap->parent = parent;
bitmap->xofs = x;
bitmap->yofs = y;
bitmap->memory = NULL;
if (bitmap->display) {
ALLEGRO_BITMAP **back;
back = _al_vector_alloc_back(&bitmap->display->bitmaps);
*back = bitmap;
}
return bitmap;
}
void UpdateEffectSlotProps(ALeffectslot *slot, ALCcontext *context)
{
struct ALeffectslotProps *props;
ALeffectState *oldstate;
/* Get an unused property container, or allocate a new one as needed. */
props = ATOMIC_LOAD(&context->FreeEffectslotProps, almemory_order_relaxed);
if(!props)
props = al_calloc(16, sizeof(*props));
else
{
struct ALeffectslotProps *next;
do {
next = ATOMIC_LOAD(&props->next, almemory_order_relaxed);
} while(ATOMIC_COMPARE_EXCHANGE_PTR_WEAK(&context->FreeEffectslotProps, &props, next,
almemory_order_seq_cst, almemory_order_acquire) == 0);
}
/* Copy in current property values. */
props->Gain = slot->Gain;
props->AuxSendAuto = slot->AuxSendAuto;
props->Type = slot->Effect.Type;
props->Props = slot->Effect.Props;
/* Swap out any stale effect state object there may be in the container, to
* delete it.
*/
ALeffectState_IncRef(slot->Effect.State);
oldstate = props->State;
props->State = slot->Effect.State;
/* Set the new container for updating internal parameters. */
props = ATOMIC_EXCHANGE_PTR(&slot->Update, props, almemory_order_acq_rel);
if(props)
{
/* If there was an unused update container, put it back in the
* freelist.
*/
if(props->State)
ALeffectState_DecRef(props->State);
props->State = NULL;
ATOMIC_REPLACE_HEAD(struct ALeffectslotProps*, &context->FreeEffectslotProps, props);
}
if(oldstate)
ALeffectState_DecRef(oldstate);
}
/* al_init will call this. */
ALLEGRO_SYSTEM *iphone_initialize(int flags)
{
(void)flags;
iphone = al_calloc(1, sizeof *iphone);
ALLEGRO_SYSTEM *sys = &iphone->system;
iphone->mutex = al_create_mutex();
iphone->cond = al_create_cond();
sys->vt = _al_get_iphone_system_interface();
_al_vector_init(&sys->displays, sizeof (ALLEGRO_DISPLAY_IPHONE *));
_al_unix_init_time();
_al_iphone_init_path();
return sys;
}
/* Returns false if the glyph is invalid.
*/
static bool get_glyph(ALLEGRO_TTF_FONT_DATA *data,
int ft_index, ALLEGRO_TTF_GLYPH_DATA **glyph)
{
ALLEGRO_TTF_GLYPH_RANGE *range;
int32_t range_start;
int lo, hi, mid;
ASSERT(glyph);
range_start = ft_index - (ft_index % RANGE_SIZE);
/* Binary search for the range. */
lo = 0;
hi = _al_vector_size(&data->glyph_ranges);
mid = (hi + lo)/2;
range = NULL;
while (lo < hi) {
ALLEGRO_TTF_GLYPH_RANGE *r = _al_vector_ref(&data->glyph_ranges, mid);
if (r->range_start == range_start) {
range = r;
break;
}
else if (r->range_start < range_start) {
lo = mid + 1;
}
else {
hi = mid;
}
mid = (hi + lo)/2;
}
if (!range) {
range = _al_vector_alloc_mid(&data->glyph_ranges, mid);
range->range_start = range_start;
range->glyphs = al_calloc(RANGE_SIZE, sizeof(ALLEGRO_TTF_GLYPH_DATA));
}
*glyph = &range->glyphs[ft_index - range_start];
/* If we're skipping cache misses and it isn't already cached, return it as invalid. */
if (data->skip_cache_misses && !(*glyph)->page_bitmap && (*glyph)->region.x >= 0) {
return false;
}
return ft_index != 0;
}
/* Creates a memory bitmap.
*/
static ALLEGRO_BITMAP *create_memory_bitmap(ALLEGRO_DISPLAY *current_display,
int w, int h, int format, int flags)
{
ALLEGRO_BITMAP *bitmap;
int pitch;
if (_al_pixel_format_is_video_only(format)) {
/* Can't have a video-only memory bitmap... */
return NULL;
}
format = _al_get_real_pixel_format(current_display, format);
bitmap = al_calloc(1, sizeof *bitmap);
pitch = w * al_get_pixel_size(format);
bitmap->vt = NULL;
bitmap->_format = format;
/* If this is really a video bitmap, we add it to the list of to
* be converted bitmaps.
*/
bitmap->_flags = flags | ALLEGRO_MEMORY_BITMAP;
bitmap->_flags &= ~ALLEGRO_VIDEO_BITMAP;
bitmap->w = w;
bitmap->h = h;
bitmap->pitch = pitch;
bitmap->_display = NULL;
bitmap->locked = false;
bitmap->cl = bitmap->ct = 0;
bitmap->cr_excl = w;
bitmap->cb_excl = h;
al_identity_transform(&bitmap->transform);
al_identity_transform(&bitmap->inverse_transform);
bitmap->inverse_transform_dirty = false;
al_identity_transform(&bitmap->proj_transform);
al_orthographic_transform(&bitmap->proj_transform, 0, 0, -1.0, w, h, 1.0);
bitmap->parent = NULL;
bitmap->xofs = bitmap->yofs = 0;
bitmap->memory = al_malloc(pitch * h);
_al_register_convert_bitmap(bitmap);
return bitmap;
}
/* Create a new X11 display, which maps directly to a GLX window. */
static ALLEGRO_DISPLAY *gp2xwiz_create_display_fb(int w, int h)
{
(void)w;
(void)h;
/* Only one display allowed at a time */
if (set_gfx_mode)
return NULL;
lc_init_rest();
ALLEGRO_DISPLAY_GP2XWIZ_FB *d = al_calloc(1, sizeof *d);
ALLEGRO_DISPLAY *display = (void *)d;
ALLEGRO_SYSTEM_GP2XWIZ *system = (void *)al_get_system_driver();
display->w = 320;
display->h = 240;
display->vt = _al_display_gp2xwiz_framebuffer_driver();
display->refresh_rate = 60;
display->flags = al_get_new_display_flags();
display->flags |= ALLEGRO_FULLSCREEN;
/* Add ourself to the list of displays. */
ALLEGRO_DISPLAY_GP2XWIZ_FB **add;
add = _al_vector_alloc_back(&system->system.displays);
*add = d;
/* Each display is an event source. */
_al_event_source_init(&display->es);
/* Create a backbuffer and point it to the framebuffer */
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
d->backbuffer = al_create_bitmap(320, 240);
d->screen_mem = d->backbuffer->memory;
d->backbuffer->memory = (unsigned char *)lc_fb1;
set_gfx_mode = true;
ALLEGRO_DEBUG("Display created successfully\n");
return display;
}
static ALLEGRO_JOYSTICK_LINUX *ljoy_allocate_structure(void)
{
ALLEGRO_JOYSTICK_LINUX **slot;
ALLEGRO_JOYSTICK_LINUX *joy;
unsigned i;
for (i = 0; i < _al_vector_size(&joysticks); i++) {
slot = _al_vector_ref(&joysticks, i);
joy = *slot;
if (joy->config_state == LJOY_STATE_UNUSED)
return joy;
}
joy = al_calloc(1, sizeof *joy);
slot = _al_vector_alloc_back(&joysticks);
*slot = joy;
return joy;
}