/* 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;
}
/* 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;
}
ALLEGRO_LOCKED_REGION *_al_ogl_lock_region_new(ALLEGRO_BITMAP *bitmap,
int x, int y, int w, int h, int format, int flags)
{
ALLEGRO_BITMAP_EXTRA_OPENGL * const ogl_bitmap = bitmap->extra;
const GLint gl_y = bitmap->h - y - h;
ALLEGRO_DISPLAY *disp;
ALLEGRO_DISPLAY *old_disp = NULL;
ALLEGRO_BITMAP *old_target = al_get_target_bitmap();
GLenum e;
bool ok;
bool restore_fbo = false;
if (format == ALLEGRO_PIXEL_FORMAT_ANY) {
/* Never pick compressed formats with ANY, as it interacts weirdly with
* existing code (e.g. al_get_pixel_size() etc) */
int bitmap_format = al_get_bitmap_format(bitmap);
if (_al_pixel_format_is_compressed(bitmap_format)) {
// XXX Get a good format from the driver?
format = ALLEGRO_PIXEL_FORMAT_ABGR_8888_LE;
}
else {
format = bitmap_format;
}
}
disp = al_get_current_display();
format = _al_get_real_pixel_format(disp, format);
/* Change OpenGL context if necessary. */
if (!disp ||
(_al_get_bitmap_display(bitmap)->ogl_extras->is_shared == false &&
_al_get_bitmap_display(bitmap) != disp))
{
old_disp = disp;
_al_set_current_display_only(_al_get_bitmap_display(bitmap));
}
ok = true;
/* Set up the pixel store state. We will need to match it when unlocking.
* There may be other pixel store state we should be setting.
* See also pitfalls 7 & 8 from:
* http://www.opengl.org/resources/features/KilgardTechniques/oglpitfall/
*/
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
{
const int pixel_size = al_get_pixel_size(format);
const int pixel_alignment = ogl_pixel_alignment(pixel_size);
glPixelStorei(GL_PACK_ALIGNMENT, pixel_alignment);
e = glGetError();
if (e) {
ALLEGRO_ERROR("glPixelStorei(GL_PACK_ALIGNMENT, %d) failed (%s).\n",
pixel_alignment, _al_gl_error_string(e));
ok = false;
}
}
if (ok) {
if (ogl_bitmap->is_backbuffer) {
ALLEGRO_DEBUG("Locking backbuffer\n");
ok = ogl_lock_region_backbuffer(bitmap, ogl_bitmap,
x, gl_y, w, h, format, flags);
}
else if (flags & ALLEGRO_LOCK_WRITEONLY) {
ALLEGRO_DEBUG("Locking non-backbuffer WRITEONLY\n");
ok = ogl_lock_region_nonbb_writeonly(bitmap, ogl_bitmap,
x, gl_y, w, h, format);
}
else {
ALLEGRO_DEBUG("Locking non-backbuffer READWRITE\n");
ok = ogl_lock_region_nonbb_readwrite(bitmap, ogl_bitmap,
x, gl_y, w, h, format, &restore_fbo);
}
}
glPopClientAttrib();
/* Restore state after switching FBO. */
if (restore_fbo) {
if (!old_target) {
/* Old target was NULL; release the context. */
_al_set_current_display_only(NULL);
}
else if (!_al_get_bitmap_display(old_target)) {
/* Old target was memory bitmap; leave the current display alone. */
}
else if (old_target != bitmap) {
/* Old target was another OpenGL bitmap. */
_al_ogl_setup_fbo(_al_get_bitmap_display(old_target), old_target);
}
}
ASSERT(al_get_target_bitmap() == old_target);
if (old_disp != NULL) {
_al_set_current_display_only(old_disp);
}
if (ok) {
return &bitmap->locked_region;
}
ALLEGRO_ERROR("Failed to lock region\n");
ASSERT(ogl_bitmap->lock_buffer == NULL);
return NULL;
}
static void ogl_unlock_region_non_readonly(ALLEGRO_BITMAP *bitmap,
ALLEGRO_BITMAP_EXTRA_OPENGL *ogl_bitmap)
{
const int lock_format = bitmap->locked_region.format;
const int gl_y = bitmap->h - bitmap->lock_y - bitmap->lock_h;
ALLEGRO_DISPLAY *old_disp = NULL;
ALLEGRO_DISPLAY *disp;
int orig_format;
bool biased_alpha = false;
GLenum e;
disp = al_get_current_display();
orig_format = _al_get_real_pixel_format(disp, _al_get_bitmap_memory_format(bitmap));
/* Change OpenGL context if necessary. */
if (!disp ||
(_al_get_bitmap_display(bitmap)->ogl_extras->is_shared == false &&
_al_get_bitmap_display(bitmap) != disp))
{
old_disp = disp;
_al_set_current_display_only(_al_get_bitmap_display(bitmap));
}
/* Keep this in sync with ogl_lock_region. */
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
{
const int lock_pixel_size = al_get_pixel_size(lock_format);
const int pixel_alignment = ogl_pixel_alignment(lock_pixel_size);
glPixelStorei(GL_UNPACK_ALIGNMENT, pixel_alignment);
e = glGetError();
if (e) {
ALLEGRO_ERROR("glPixelStorei(GL_UNPACK_ALIGNMENT, %d) failed (%s).\n",
pixel_alignment, _al_gl_error_string(e));
}
}
if (exactly_15bpp(lock_format)) {
/* OpenGL does not support 15-bpp internal format without an alpha,
* so when storing such data we must ensure the alpha bit is set.
*/
glPixelTransferi(GL_ALPHA_BIAS, 1);
biased_alpha = true;
}
if (ogl_bitmap->is_backbuffer) {
ALLEGRO_DEBUG("Unlocking backbuffer\n");
ogl_unlock_region_backbuffer(bitmap, ogl_bitmap, gl_y);
}
else {
glBindTexture(GL_TEXTURE_2D, ogl_bitmap->texture);
if (ogl_bitmap->fbo_info) {
ALLEGRO_DEBUG("Unlocking non-backbuffer (FBO)\n");
ogl_unlock_region_nonbb_fbo(bitmap, ogl_bitmap, gl_y, orig_format);
}
else {
ALLEGRO_DEBUG("Unlocking non-backbuffer (non-FBO)\n");
ogl_unlock_region_nonbb_nonfbo(bitmap, ogl_bitmap, gl_y);
}
/* If using FBOs, we need to regenerate mipmaps explicitly now. */
/* XXX why don't we check ogl_bitmap->fbo_info? */
if ((al_get_bitmap_flags(bitmap) & ALLEGRO_MIPMAP) &&
al_get_opengl_extension_list()->ALLEGRO_GL_EXT_framebuffer_object)
{
glGenerateMipmapEXT(GL_TEXTURE_2D);
e = glGetError();
if (e) {
ALLEGRO_ERROR("glGenerateMipmapEXT for texture %d failed (%s).\n",
ogl_bitmap->texture, _al_gl_error_string(e));
}
}
}
if (biased_alpha) {
glPixelTransferi(GL_ALPHA_BIAS, 0);
}
glPopClientAttrib();
if (old_disp) {
_al_set_current_display_only(old_disp);
}
}
ALLEGRO_LOCKED_REGION *_al_ogl_lock_region_new(ALLEGRO_BITMAP *bitmap,
int x, int y, int w, int h, int format, int flags)
{
ALLEGRO_BITMAP_EXTRA_OPENGL * const ogl_bitmap = bitmap->extra;
const GLint gl_y = bitmap->h - y - h;
ALLEGRO_DISPLAY *disp;
ALLEGRO_DISPLAY *old_disp = NULL;
GLenum e;
if (format == ALLEGRO_PIXEL_FORMAT_ANY) {
format = bitmap->format;
}
disp = al_get_current_display();
format = _al_get_real_pixel_format(disp, format);
/* Change OpenGL context if necessary. */
if (!disp ||
(bitmap->display->ogl_extras->is_shared == false &&
bitmap->display != disp))
{
old_disp = disp;
_al_set_current_display_only(bitmap->display);
}
/* Set up the pixel store state. We will need to match it when unlocking.
* There may be other pixel store state we should be setting.
* See also pitfalls 7 & 8 from:
* http://www.opengl.org/resources/features/KilgardTechniques/oglpitfall/
*/
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
{
const int pixel_size = al_get_pixel_size(format);
const int pixel_alignment = ogl_pixel_alignment(pixel_size);
glPixelStorei(GL_PACK_ALIGNMENT, pixel_alignment);
e = glGetError();
if (e) {
ALLEGRO_ERROR("glPixelStorei(GL_PACK_ALIGNMENT, %d) failed (%s).\n",
pixel_alignment, _al_gl_error_string(e));
}
}
if (ogl_bitmap->is_backbuffer) {
ALLEGRO_DEBUG("Locking backbuffer\n");
ogl_lock_region_backbuffer(bitmap, ogl_bitmap,
x, gl_y, w, h, format, flags);
}
else if (flags & ALLEGRO_LOCK_WRITEONLY) {
ALLEGRO_DEBUG("Locking non-backbuffer WRITEONLY\n");
ogl_lock_region_nonbb_writeonly(bitmap, ogl_bitmap,
x, gl_y, w, h, format);
}
else {
ALLEGRO_DEBUG("Locking non-backbuffer READWRITE\n");
ogl_lock_region_nonbb_readwrite(bitmap, ogl_bitmap,
x, gl_y, w, h, format);
}
glPopClientAttrib();
if (old_disp != NULL) {
_al_set_current_display_only(old_disp);
}
return &bitmap->locked_region;
}
static ALLEGRO_LOCKED_REGION *d3d_lock_region(ALLEGRO_BITMAP *bitmap,
int x, int y, int w, int h, int format,
int flags)
{
ALLEGRO_BITMAP_D3D *d3d_bmp = (ALLEGRO_BITMAP_D3D *)bitmap;
if (d3d_bmp->display->device_lost)
return NULL;
RECT rect;
DWORD Flags = flags & ALLEGRO_LOCK_READONLY ? D3DLOCK_READONLY : 0;
int f = _al_get_real_pixel_format(al_get_current_display(), format);
if (f < 0) {
return NULL;
}
rect.left = x;
rect.right = x + w;
rect.top = y;
rect.bottom = y + h;
if (d3d_bmp->is_backbuffer) {
ALLEGRO_DISPLAY_D3D *d3d_disp = (ALLEGRO_DISPLAY_D3D *)bitmap->display;
if (d3d_disp->render_target->LockRect(&d3d_bmp->locked_rect, &rect, Flags) != D3D_OK) {
ALLEGRO_ERROR("LockRect failed in d3d_lock_region.\n");
return NULL;
}
}
else {
LPDIRECT3DTEXTURE9 texture;
if (_al_d3d_render_to_texture_supported()) {
/*
* Sync bitmap->memory with texture
*/
bitmap->locked = false;
_al_d3d_sync_bitmap(bitmap);
bitmap->locked = true;
texture = d3d_bmp->system_texture;
}
else {
texture = d3d_bmp->video_texture;
}
if (texture->LockRect(0, &d3d_bmp->locked_rect, &rect, Flags) != D3D_OK) {
ALLEGRO_ERROR("LockRect failed in d3d_lock_region.\n");
return NULL;
}
}
if (format == ALLEGRO_PIXEL_FORMAT_ANY || bitmap->format == format || f == bitmap->format) {
bitmap->locked_region.data = d3d_bmp->locked_rect.pBits;
bitmap->locked_region.format = bitmap->format;
bitmap->locked_region.pitch = d3d_bmp->locked_rect.Pitch;
bitmap->locked_region.pixel_size = al_get_pixel_size(bitmap->format);
}
else {
bitmap->locked_region.pitch = al_get_pixel_size(f) * w;
bitmap->locked_region.data = al_malloc(bitmap->locked_region.pitch*h);
bitmap->locked_region.format = f;
bitmap->locked_region.pixel_size = al_get_pixel_size(bitmap->format);
if (!(bitmap->lock_flags & ALLEGRO_LOCK_WRITEONLY)) {
_al_convert_bitmap_data(
d3d_bmp->locked_rect.pBits, bitmap->format, d3d_bmp->locked_rect.Pitch,
bitmap->locked_region.data, f, bitmap->locked_region.pitch,
0, 0, 0, 0, w, h);
}
}
return &bitmap->locked_region;
}
/* Function: al_lock_bitmap_region
*/
ALLEGRO_LOCKED_REGION *al_lock_bitmap_region(ALLEGRO_BITMAP *bitmap,
int x, int y, int width, int height, int format, int flags)
{
ASSERT(x >= 0);
ASSERT(y >= 0);
ASSERT(width >= 0);
ASSERT(height >= 0);
/* For sub-bitmaps */
if (bitmap->parent) {
x += bitmap->xofs;
y += bitmap->yofs;
bitmap = bitmap->parent;
}
if (bitmap->locked)
return NULL;
ASSERT(x+width <= bitmap->w);
ASSERT(y+height <= bitmap->h);
bitmap->lock_x = x;
bitmap->lock_y = y;
bitmap->lock_w = width;
bitmap->lock_h = height;
bitmap->lock_flags = flags;
if (bitmap->flags & ALLEGRO_MEMORY_BITMAP) {
int f = _al_get_real_pixel_format(al_get_current_display(), format);
if (f < 0) {
return NULL;
}
ASSERT(bitmap->memory);
if (format == ALLEGRO_PIXEL_FORMAT_ANY || bitmap->format == format || f == bitmap->format) {
bitmap->locked_region.data = bitmap->memory
+ bitmap->pitch * y + x * al_get_pixel_size(bitmap->format);
bitmap->locked_region.format = bitmap->format;
bitmap->locked_region.pitch = bitmap->pitch;
bitmap->locked_region.pixel_size = al_get_pixel_size(bitmap->format);
}
else {
bitmap->locked_region.pitch = al_get_pixel_size(f) * width;
bitmap->locked_region.data = al_malloc(bitmap->locked_region.pitch*height);
bitmap->locked_region.format = f;
bitmap->locked_region.pixel_size = al_get_pixel_size(f);
if (!(bitmap->lock_flags & ALLEGRO_LOCK_WRITEONLY)) {
_al_convert_bitmap_data(
bitmap->memory, bitmap->format, bitmap->pitch,
bitmap->locked_region.data, f, bitmap->locked_region.pitch,
x, y, 0, 0, width, height);
}
}
}
else {
if (!bitmap->vt->lock_region(bitmap, x, y, width, height, format, flags)) {
return NULL;
}
}
bitmap->locked = true;
return &bitmap->locked_region;
}
