static CoglBool
_cogl_texture_driver_upload_subregion_to_gl (CoglContext *ctx,
CoglTexture *texture,
CoglBool is_foreign,
int src_x,
int src_y,
int dst_x,
int dst_y,
int width,
int height,
int level,
CoglBitmap *source_bmp,
GLuint source_gl_format,
GLuint source_gl_type,
CoglError **error)
{
GLenum gl_target;
GLuint gl_handle;
uint8_t *data;
CoglPixelFormat source_format = cogl_bitmap_get_format (source_bmp);
int bpp = _cogl_pixel_format_get_bytes_per_pixel (source_format);
CoglBitmap *slice_bmp;
int rowstride;
CoglBool status = TRUE;
CoglError *internal_error = NULL;
int level_width;
int level_height;
cogl_texture_get_gl_texture (texture, &gl_handle, &gl_target);
/* If we have the GL_EXT_unpack_subimage extension then we can
upload from subregions directly. Otherwise we may need to copy
the bitmap */
if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE) &&
(src_x != 0 || src_y != 0 ||
width != cogl_bitmap_get_width (source_bmp) ||
height != cogl_bitmap_get_height (source_bmp)))
{
slice_bmp =
_cogl_bitmap_new_with_malloc_buffer (ctx,
width, height,
source_format,
error);
if (!slice_bmp)
return FALSE;
if (!_cogl_bitmap_copy_subregion (source_bmp,
slice_bmp,
src_x, src_y,
0, 0, /* dst_x/y */
width, height,
error))
{
cogl_object_unref (slice_bmp);
return FALSE;
}
src_x = src_y = 0;
}
else
{
slice_bmp = prepare_bitmap_alignment_for_upload (ctx, source_bmp, error);
if (!slice_bmp)
return FALSE;
}
rowstride = cogl_bitmap_get_rowstride (slice_bmp);
/* Setup gl alignment to match rowstride and top-left corner */
prep_gl_for_pixels_upload_full (ctx, rowstride, src_x, src_y, bpp);
data = _cogl_bitmap_gl_bind (slice_bmp, COGL_BUFFER_ACCESS_READ, 0, &internal_error);
/* NB: _cogl_bitmap_gl_bind() may return NULL when successfull so we
* have to explicitly check the cogl error pointer to catch
* problems... */
if (internal_error)
{
_cogl_propagate_error (error, internal_error);
cogl_object_unref (slice_bmp);
return FALSE;
}
_cogl_bind_gl_texture_transient (gl_target, gl_handle, is_foreign);
/* Clear any GL errors */
_cogl_gl_util_clear_gl_errors (ctx);
_cogl_texture_get_level_size (texture,
level,
&level_width,
&level_height,
NULL);
if (level_width == width && level_height == height)
{
/* GL gets upset if you use glTexSubImage2D to define the
* contents of a mipmap level so we make sure to use
* glTexImage2D if we are uploading a full mipmap level.
*/
ctx->glTexImage2D (gl_target,
level,
_cogl_texture_gl_get_format (texture),
width,
height,
0,
source_gl_format,
source_gl_type,
data);
}
else
{
/* GL gets upset if you use glTexSubImage2D to initialize the
* contents of a mipmap level so if this is the first time
* we've seen a request to upload to this level we call
* glTexImage2D first to assert that the storage for this
* level exists.
*/
if (texture->max_level < level)
{
ctx->glTexImage2D (gl_target,
level,
_cogl_texture_gl_get_format (texture),
level_width,
level_height,
0,
source_gl_format,
source_gl_type,
NULL);
}
ctx->glTexSubImage2D (gl_target,
level,
dst_x, dst_y,
width, height,
source_gl_format,
source_gl_type,
data);
}
if (_cogl_gl_util_catch_out_of_memory (ctx, error))
status = FALSE;
_cogl_bitmap_gl_unbind (slice_bmp);
cogl_object_unref (slice_bmp);
return status;
}
CoglTexture *
cogl_texture_new_from_bitmap (CoglBitmap *bitmap,
CoglTextureFlags flags,
CoglPixelFormat internal_format,
CoglError **error)
{
CoglContext *ctx = _cogl_bitmap_get_context (bitmap);
CoglAtlasTexture *atlas_tex;
CoglTexture *tex;
CoglError *internal_error = NULL;
/* First try putting the texture in the atlas */
if ((atlas_tex = _cogl_atlas_texture_new_from_bitmap (bitmap,
flags,
internal_format,
&internal_error)))
return COGL_TEXTURE (atlas_tex);
if (cogl_error_matches (internal_error,
COGL_SYSTEM_ERROR,
COGL_SYSTEM_ERROR_NO_MEMORY))
{
_cogl_propagate_error (error, internal_error);
return NULL;
}
cogl_error_free (internal_error);
internal_error = NULL;
/* If that doesn't work try a fast path 2D texture */
if ((_cogl_util_is_pot (bitmap->width) &&
_cogl_util_is_pot (bitmap->height)) ||
(cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT_BASIC) &&
cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP)))
{
tex = COGL_TEXTURE (cogl_texture_2d_new_from_bitmap (bitmap,
internal_format,
&internal_error));
if (cogl_error_matches (internal_error,
COGL_SYSTEM_ERROR,
COGL_SYSTEM_ERROR_NO_MEMORY))
{
_cogl_propagate_error (error, internal_error);
return NULL;
}
if (!tex)
{
cogl_error_free (internal_error);
internal_error = NULL;
}
}
else
tex = NULL;
if (tex)
{
CoglBool auto_mipmap = !(flags & COGL_TEXTURE_NO_AUTO_MIPMAP);
cogl_primitive_texture_set_auto_mipmap (COGL_PRIMITIVE_TEXTURE (tex),
auto_mipmap);
}
else
{
/* Otherwise create a sliced texture */
tex = COGL_TEXTURE (_cogl_texture_2d_sliced_new_from_bitmap (bitmap,
flags,
internal_format,
error));
}
return tex;
}
