CoglBitmap * _cogl_bitmap_copy (CoglBitmap *src_bmp, CoglError **error) { CoglBitmap *dst_bmp; CoglPixelFormat src_format = cogl_bitmap_get_format (src_bmp); int width = cogl_bitmap_get_width (src_bmp); int height = cogl_bitmap_get_height (src_bmp); dst_bmp = _cogl_bitmap_new_with_malloc_buffer (src_bmp->context, width, height, src_format, error); if (!dst_bmp) return NULL; if (!_cogl_bitmap_copy_subregion (src_bmp, dst_bmp, 0, 0, /* src_x/y */ 0, 0, /* dst_x/y */ width, height, error)) { cogl_object_unref (dst_bmp); return NULL; } return dst_bmp; }
void _cogl_texture_driver_upload_subregion_to_gl (GLenum gl_target, GLuint gl_handle, int src_x, int src_y, int dst_x, int dst_y, int width, int height, CoglBitmap *source_bmp, GLuint source_gl_format, GLuint source_gl_type) { int bpp = _cogl_get_format_bpp (source_bmp->format); CoglBitmap slice_bmp; /* NB: GLES doesn't support the GL_UNPACK_ROW_LENGTH, GL_UNPACK_SKIP_PIXELS * or GL_UNPACK_SKIP_ROWS pixel store options so we can't directly source a * sub-region from source_bmp, we need to use a transient bitmap instead. */ /* FIXME: optimize by not copying to intermediate slice bitmap when source * rowstride = bpp * width and the texture image is not sliced */ /* Setup temp bitmap for slice subregion */ slice_bmp.format = source_bmp->format; slice_bmp.width = width; slice_bmp.height = height; slice_bmp.rowstride = bpp * slice_bmp.width; slice_bmp.data = g_malloc (slice_bmp.rowstride * slice_bmp.height); /* Setup gl alignment to match rowstride and top-left corner */ _cogl_texture_driver_prep_gl_for_pixels_upload (slice_bmp.rowstride, bpp); /* Copy subregion data */ _cogl_bitmap_copy_subregion (source_bmp, &slice_bmp, src_x, src_y, 0, 0, slice_bmp.width, slice_bmp.height); GE( glBindTexture (gl_target, gl_handle) ); GE( glTexSubImage2D (gl_target, 0, dst_x, dst_y, width, height, source_gl_format, source_gl_type, slice_bmp.data) ); /* Free temp bitmap */ g_free (slice_bmp.data); }
void _cogl_texture_driver_upload_to_gl (GLenum gl_target, GLuint gl_handle, CoglBitmap *source_bmp, GLint internal_gl_format, GLuint source_gl_format, GLuint source_gl_type) { int bpp = _cogl_get_format_bpp (source_bmp->format); CoglBitmap bmp = *source_bmp; gboolean bmp_owner = FALSE; /* If the rowstride can't be specified with just GL_ALIGNMENT alone then we need to copy the bitmap because there is no GL_ROW_LENGTH */ if (source_bmp->rowstride / bpp != source_bmp->width) { bmp.rowstride = bpp * bmp.width; bmp.data = g_malloc (bmp.rowstride * bmp.height); bmp_owner = TRUE; _cogl_bitmap_copy_subregion (source_bmp, &bmp, 0, 0, 0, 0, bmp.width, bmp.height); } /* Setup gl alignment to match rowstride and top-left corner */ _cogl_texture_driver_prep_gl_for_pixels_upload (bmp.rowstride, bpp); GE( glBindTexture (gl_target, gl_handle) ); GE( glTexImage2D (gl_target, 0, internal_gl_format, bmp.width, bmp.height, 0, source_gl_format, source_gl_type, bmp.data) ); if (bmp_owner) g_free (bmp.data); }
static CoglBool _cogl_texture_driver_upload_to_gl_3d (CoglContext *ctx, GLenum gl_target, GLuint gl_handle, CoglBool is_foreign, GLint height, GLint depth, CoglBitmap *source_bmp, GLint internal_gl_format, GLuint source_gl_format, GLuint source_gl_type, CoglError **error) { CoglPixelFormat source_format = cogl_bitmap_get_format (source_bmp); int bpp = _cogl_pixel_format_get_bytes_per_pixel (source_format); int rowstride = cogl_bitmap_get_rowstride (source_bmp); int bmp_width = cogl_bitmap_get_width (source_bmp); int bmp_height = cogl_bitmap_get_height (source_bmp); uint8_t *data; GLenum gl_error; _cogl_bind_gl_texture_transient (gl_target, gl_handle, is_foreign); /* If the rowstride or image height can't be specified with just GL_ALIGNMENT alone then we need to copy the bitmap because there is no GL_ROW_LENGTH */ if (rowstride / bpp != bmp_width || height != bmp_height / depth) { CoglBitmap *bmp; int image_height = bmp_height / depth; CoglPixelFormat source_bmp_format = cogl_bitmap_get_format (source_bmp); int i; _cogl_texture_driver_prep_gl_for_pixels_upload (ctx, bmp_width * bpp, bpp); /* Initialize the texture with empty data and then upload each image with a sub-region update */ /* Clear any GL errors */ while ((gl_error = ctx->glGetError ()) != GL_NO_ERROR) ; ctx->glTexImage3D (gl_target, 0, /* level */ internal_gl_format, bmp_width, height, depth, 0, source_gl_format, source_gl_type, NULL); if (_cogl_gl_util_catch_out_of_memory (ctx, error)) return FALSE; bmp = _cogl_bitmap_new_with_malloc_buffer (ctx, bmp_width, height, source_bmp_format, error); if (!bmp) return FALSE; for (i = 0; i < depth; i++) { if (!_cogl_bitmap_copy_subregion (source_bmp, bmp, 0, image_height * i, 0, 0, bmp_width, height, error)) { cogl_object_unref (bmp); return FALSE; } data = _cogl_bitmap_gl_bind (bmp, COGL_BUFFER_ACCESS_READ, 0, error); if (!data) { cogl_object_unref (bmp); return FALSE; } /* Clear any GL errors */ while ((gl_error = ctx->glGetError ()) != GL_NO_ERROR) ; ctx->glTexSubImage3D (gl_target, 0, /* level */ 0, /* xoffset */ 0, /* yoffset */ i, /* zoffset */ bmp_width, /* width */ height, /* height */ 1, /* depth */ source_gl_format, source_gl_type, data); if (_cogl_gl_util_catch_out_of_memory (ctx, error)) { cogl_object_unref (bmp); _cogl_bitmap_gl_unbind (bmp); return FALSE; } _cogl_bitmap_gl_unbind (bmp); } cogl_object_unref (bmp); } else { data = _cogl_bitmap_gl_bind (source_bmp, COGL_BUFFER_ACCESS_READ, 0, error); if (!data) return FALSE; _cogl_texture_driver_prep_gl_for_pixels_upload (ctx, rowstride, bpp); /* Clear any GL errors */ while ((gl_error = ctx->glGetError ()) != GL_NO_ERROR) ; ctx->glTexImage3D (gl_target, 0, /* level */ internal_gl_format, bmp_width, height, depth, 0, source_gl_format, source_gl_type, data); if (_cogl_gl_util_catch_out_of_memory (ctx, error)) { _cogl_bitmap_gl_unbind (source_bmp); return FALSE; } _cogl_bitmap_gl_unbind (source_bmp); } return TRUE; }
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; GLenum gl_error; 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 (!(ctx->private_feature_flags & 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 */ while ((gl_error = ctx->glGetError ()) != GL_NO_ERROR) ; _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; }
void _cogl_texture_driver_upload_to_gl_3d (GLenum gl_target, GLuint gl_handle, gboolean is_foreign, GLint height, GLint depth, CoglBitmap *source_bmp, GLint internal_gl_format, GLuint source_gl_format, GLuint source_gl_type) { int bpp = _cogl_get_format_bpp (_cogl_bitmap_get_format (source_bmp)); int rowstride = _cogl_bitmap_get_rowstride (source_bmp); int bmp_width = _cogl_bitmap_get_width (source_bmp); int bmp_height = _cogl_bitmap_get_height (source_bmp); guint8 *data; _COGL_GET_CONTEXT (ctx, NO_RETVAL); _cogl_bind_gl_texture_transient (gl_target, gl_handle, is_foreign); /* If the rowstride or image height can't be specified with just GL_ALIGNMENT alone then we need to copy the bitmap because there is no GL_ROW_LENGTH */ if (rowstride / bpp != bmp_width || height != bmp_height / depth) { CoglBitmap *bmp; int image_height = bmp_height / depth; int i; _cogl_texture_driver_prep_gl_for_pixels_upload (bmp_width * bpp, bpp); /* Initialize the texture with empty data and then upload each image with a sub-region update */ GE( glTexImage3D (gl_target, 0, /* level */ internal_gl_format, bmp_width, height, depth, 0, source_gl_format, source_gl_type, NULL) ); bmp = _cogl_bitmap_new_from_data (g_malloc (bpp * bmp_width * height), _cogl_bitmap_get_format (source_bmp), bmp_width, height, bpp * bmp_width, (CoglBitmapDestroyNotify) g_free, NULL); for (i = 0; i < depth; i++) { _cogl_bitmap_copy_subregion (source_bmp, bmp, 0, image_height * i, 0, 0, bmp_width, height); data = _cogl_bitmap_bind (bmp, COGL_BUFFER_ACCESS_READ, 0); GE( glTexSubImage3D (gl_target, 0, /* level */ 0, /* xoffset */ 0, /* yoffset */ i, /* zoffset */ bmp_width, /* width */ height, /* height */ 1, /* depth */ source_gl_format, source_gl_type, data) ); _cogl_bitmap_unbind (bmp); } cogl_object_unref (bmp); } else { data = _cogl_bitmap_bind (source_bmp, COGL_BUFFER_ACCESS_READ, 0); _cogl_texture_driver_prep_gl_for_pixels_upload (rowstride, bpp); GE( glTexImage3D (gl_target, 0, /* level */ internal_gl_format, bmp_width, height, depth, 0, source_gl_format, source_gl_type, data) ); _cogl_bitmap_unbind (source_bmp); } }
void _cogl_texture_driver_upload_subregion_to_gl (GLenum gl_target, GLuint gl_handle, gboolean is_foreign, int src_x, int src_y, int dst_x, int dst_y, int width, int height, CoglBitmap *source_bmp, GLuint source_gl_format, GLuint source_gl_type) { guint8 *data; CoglPixelFormat source_format = _cogl_bitmap_get_format (source_bmp); int bpp = _cogl_get_format_bpp (source_format); CoglBitmap *slice_bmp; int rowstride; /* If we are copying a sub region of the source bitmap then we need to copy it because GLES does not support GL_UNPACK_ROW_LENGTH */ if (src_x != 0 || src_y != 0 || width != _cogl_bitmap_get_width (source_bmp) || height != _cogl_bitmap_get_height (source_bmp)) { rowstride = bpp * width; rowstride = (rowstride + 3) & ~3; slice_bmp = _cogl_bitmap_new_from_data (g_malloc (height * rowstride), source_format, width, height, rowstride, (CoglBitmapDestroyNotify) g_free, NULL); _cogl_bitmap_copy_subregion (source_bmp, slice_bmp, src_x, src_y, 0, 0, /* dst_x/y */ width, height); } else { slice_bmp = prepare_bitmap_alignment_for_upload (source_bmp); rowstride = _cogl_bitmap_get_rowstride (slice_bmp); } /* Setup gl alignment to match rowstride and top-left corner */ _cogl_texture_driver_prep_gl_for_pixels_upload (rowstride, bpp); data = _cogl_bitmap_bind (slice_bmp, COGL_BUFFER_ACCESS_READ, 0); _cogl_bind_gl_texture_transient (gl_target, gl_handle, is_foreign); GE( glTexSubImage2D (gl_target, 0, dst_x, dst_y, width, height, source_gl_format, source_gl_type, data) ); _cogl_bitmap_unbind (slice_bmp); cogl_object_unref (slice_bmp); }
/* Reads back the contents of a texture by rendering it to the framebuffer * and reading back the resulting pixels. * * It will perform multiple renders if the texture is larger than the * current glViewport. * * It assumes the projection and modelview have already been setup so * that rendering to 0,0 with the same width and height of the viewport * will exactly cover the viewport. * * NB: Normally this approach isn't normally used since we can just use * glGetTexImage, but may be used as a fallback in some circumstances. */ static void do_texture_draw_and_read (CoglHandle handle, CoglBitmap *target_bmp, GLint *viewport) { int bpp; float rx1, ry1; float rx2, ry2; float tx1, ty1; float tx2, ty2; int bw, bh; CoglBitmap *rect_bmp; unsigned int tex_width, tex_height; bpp = _cogl_get_format_bpp (COGL_PIXEL_FORMAT_RGBA_8888); tex_width = cogl_texture_get_width (handle); tex_height = cogl_texture_get_height (handle); ry2 = 0; ty2 = 0; /* Walk Y axis until whole bitmap height consumed */ for (bh = tex_height; bh > 0; bh -= viewport[3]) { /* Rectangle Y coords */ ry1 = ry2; ry2 += (bh < viewport[3]) ? bh : viewport[3]; /* Normalized texture Y coords */ ty1 = ty2; ty2 = (ry2 / (float) tex_height); rx2 = 0; tx2 = 0; /* Walk X axis until whole bitmap width consumed */ for (bw = tex_width; bw > 0; bw-=viewport[2]) { int width; int height; int rowstride; guint8 *data; /* Rectangle X coords */ rx1 = rx2; rx2 += (bw < viewport[2]) ? bw : viewport[2]; width = rx2 - rx1; height = ry2 - ry1; rowstride = width * bpp; /* Normalized texture X coords */ tx1 = tx2; tx2 = (rx2 / (float) tex_width); /* Draw a portion of texture */ cogl_rectangle_with_texture_coords (0, 0, rx2 - rx1, ry2 - ry1, tx1, ty1, tx2, ty2); data = g_malloc (height * rowstride); /* Read into a temporary bitmap */ rect_bmp = _cogl_bitmap_new_from_data (data, COGL_PIXEL_FORMAT_RGBA_8888, width, height, rowstride, (CoglBitmapDestroyNotify) g_free, NULL); cogl_read_pixels (viewport[0], viewport[1], width, height, COGL_READ_PIXELS_COLOR_BUFFER, COGL_PIXEL_FORMAT_RGBA_8888_PRE, data); /* Copy to target bitmap */ _cogl_bitmap_copy_subregion (rect_bmp, target_bmp, 0,0, rx1,ry1, width, height); /* Free temp bitmap */ cogl_object_unref (rect_bmp); } } }
void _cogl_read_pixels_with_rowstride (int x, int y, int width, int height, CoglReadPixelsFlags source, CoglPixelFormat format, guint8 *pixels, int rowstride) { CoglFramebuffer *framebuffer = _cogl_get_read_framebuffer (); int framebuffer_height; int bpp; CoglBitmap *bmp; GLenum gl_intformat; GLenum gl_format; GLenum gl_type; CoglPixelFormat bmp_format; gboolean pack_invert_set; _COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_RETURN_IF_FAIL (source == COGL_READ_PIXELS_COLOR_BUFFER); if (width == 1 && height == 1 && !framebuffer->clear_clip_dirty) { /* If everything drawn so far for this frame is still in the * Journal then if all of the rectangles only have a flat * opaque color we have a fast-path for reading a single pixel * that avoids the relatively high cost of flushing primitives * to be drawn on the GPU (considering how simple the geometry * is in this case) and then blocking on the long GPU pipelines * for the result. */ if (_cogl_framebuffer_try_fast_read_pixel (framebuffer, x, y, source, format, pixels)) return; } /* make sure any batched primitives get emitted to the GL driver * before issuing our read pixels... * * XXX: Note we currently use cogl_flush to ensure *all* journals * are flushed here and not _cogl_journal_flush because we don't * track the dependencies between framebuffers so we don't know if * the current framebuffer depends on the contents of other * framebuffers which could also have associated journal entries. */ cogl_flush (); _cogl_framebuffer_flush_state (cogl_get_draw_framebuffer (), framebuffer, COGL_FRAMEBUFFER_STATE_BIND); framebuffer_height = cogl_framebuffer_get_height (framebuffer); /* The y co-ordinate should be given in OpenGL's coordinate system * so 0 is the bottom row * * NB: all offscreen rendering is done upside down so no conversion * is necissary in this case. */ if (!cogl_is_offscreen (framebuffer)) y = framebuffer_height - y - height; /* Initialise the CoglBitmap */ bpp = _cogl_get_format_bpp (format); bmp_format = format; if ((format & COGL_A_BIT)) { /* We match the premultiplied state of the target buffer to the * premultiplied state of the framebuffer so that it will get * converted to the right format below */ if ((framebuffer->format & COGL_PREMULT_BIT)) bmp_format |= COGL_PREMULT_BIT; else bmp_format &= ~COGL_PREMULT_BIT; } bmp = _cogl_bitmap_new_from_data (pixels, bmp_format, width, height, rowstride, NULL, NULL); ctx->texture_driver->pixel_format_to_gl (format, &gl_intformat, &gl_format, &gl_type); /* NB: All offscreen rendering is done upside down so there is no need * to flip in this case... */ if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_MESA_PACK_INVERT) && !cogl_is_offscreen (framebuffer)) { GE (ctx, glPixelStorei (GL_PACK_INVERT_MESA, TRUE)); pack_invert_set = TRUE; } else pack_invert_set = FALSE; /* Under GLES only GL_RGBA with GL_UNSIGNED_BYTE as well as an implementation specific format under GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES and GL_IMPLEMENTATION_COLOR_READ_TYPE_OES is supported. We could try to be more clever and check if the requested type matches that but we would need some reliable functions to convert from GL types to Cogl types. For now, lets just always read in GL_RGBA/GL_UNSIGNED_BYTE and convert if necessary. We also need to use this intermediate buffer if the rowstride has padding because GLES does not support setting GL_ROW_LENGTH */ if (ctx->driver != COGL_DRIVER_GL && (gl_format != GL_RGBA || gl_type != GL_UNSIGNED_BYTE || rowstride != 4 * width)) { CoglBitmap *tmp_bmp, *dst_bmp; guint8 *tmp_data = g_malloc (width * height * 4); tmp_bmp = _cogl_bitmap_new_from_data (tmp_data, COGL_PIXEL_FORMAT_RGBA_8888 | (bmp_format & COGL_PREMULT_BIT), width, height, 4 * width, (CoglBitmapDestroyNotify) g_free, NULL); ctx->texture_driver->prep_gl_for_pixels_download (4 * width, 4); GE( ctx, glReadPixels (x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, tmp_data) ); /* CoglBitmap doesn't currently have a way to convert without allocating its own buffer so we have to copy the data again */ if ((dst_bmp = _cogl_bitmap_convert_format_and_premult (tmp_bmp, format))) { _cogl_bitmap_copy_subregion (dst_bmp, bmp, 0, 0, 0, 0, width, height); cogl_object_unref (dst_bmp); } else { /* FIXME: there's no way to report an error here so we'll just have to leave the data initialised */ } cogl_object_unref (tmp_bmp); } else { ctx->texture_driver->prep_gl_for_pixels_download (rowstride, bpp); GE( ctx, glReadPixels (x, y, width, height, gl_format, gl_type, pixels) ); /* Convert to the premult format specified by the caller in-place. This will do nothing if the premult status is already correct. */ _cogl_bitmap_convert_premult_status (bmp, format); } /* Currently this function owns the pack_invert state and we don't want this * to interfere with other Cogl components so all other code can assume that * we leave the pack_invert state off. */ if (pack_invert_set) GE (ctx, glPixelStorei (GL_PACK_INVERT_MESA, FALSE)); /* NB: All offscreen rendering is done upside down so there is no need * to flip in this case... */ if (!cogl_is_offscreen (framebuffer) && !pack_invert_set) { guint8 *temprow = g_alloca (rowstride * sizeof (guint8)); /* vertically flip the buffer in-place */ for (y = 0; y < height / 2; y++) { if (y != height - y - 1) /* skip center row */ { memcpy (temprow, pixels + y * rowstride, rowstride); memcpy (pixels + y * rowstride, pixels + (height - y - 1) * rowstride, rowstride); memcpy (pixels + (height - y - 1) * rowstride, temprow, rowstride); } } } cogl_object_unref (bmp); }