mutter/cogl/cogl-bitmap.h

289 lines
8.3 KiB
C
Raw Normal View History

/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2007,2008,2009 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
*/
#if !defined(__COGL_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only <cogl/cogl.h> can be included directly."
#endif
#ifndef __COGL_BITMAP_H__
#define __COGL_BITMAP_H__
#include <cogl/cogl-types.h>
#include <cogl/cogl-buffer.h>
Change API so that CoglPixelBuffer no longer knows its w/h/format The idea is that CoglPixelBuffer should just be a buffer that can be used for pixel data and it has no idea about the details of any images that are stored in it. This is analogous to CoglAttributeBuffer which itself does not have any information about the attributes. When you want to use a pixel buffer you should create a CoglBitmap which points to a region of the attribute buffer and provides the extra needed information such as the width, height and format. That way it is also possible to use a single CoglPixelBuffer with multiple bitmaps. The changes that are made are: • cogl_pixel_buffer_new_with_size has been removed and in its place is cogl_bitmap_new_with_size. This will create a pixel buffer at the right size and rowstride for the given width/height/format and immediately create a single CoglBitmap to point into it. The old function had an out-parameter for the stride of the image but with the new API this should be queriable from the bitmap (although there is no function for this yet). • There is now a public cogl_pixel_buffer_new constructor. This takes a size in bytes and data pointer similarly to cogl_attribute_buffer_new. • cogl_texture_new_from_buffer has been removed. If you want to create a texture from a pixel buffer you should wrap it up in a bitmap first. There is already API to create a texture from a bitmap. This patch also does a bit of header juggling because cogl-context.h was including cogl-texture.h and cogl-framebuffer.h which were causing some circular dependencies when cogl-bitmap.h includes cogl-context.h. These weren't actually needed in cogl-context.h itself but a few other headers were relying on them being included so this adds the #includes where necessary. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-25 15:04:45 -05:00
#include <cogl/cogl-context.h>
#include <cogl/cogl-pixel-buffer.h>
G_BEGIN_DECLS
typedef struct _CoglBitmap CoglBitmap;
/**
* SECTION:cogl-bitmap
* @short_description: Fuctions for loading images
*
* Cogl allows loading image data into memory as CoglBitmaps without
* loading them immediately into GPU textures.
*
* #CoglBitmap is available since Cogl 1.0
*/
/**
* cogl_bitmap_new_from_file:
* @filename: the file to load.
* @error: a #GError or %NULL.
*
* Loads an image file from disk. This function can be safely called from
* within a thread.
*
* Return value: a #CoglBitmap to the new loaded image data, or
* %NULL if loading the image failed.
*
* Since: 1.0
*/
CoglBitmap *
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
cogl_bitmap_new_from_file (const char *filename,
GError **error);
#if defined (COGL_ENABLE_EXPERIMENTAL_API)
/**
* cogl_bitmap_new_from_buffer:
* @buffer: A #CoglBuffer containing image data
* @format: The #CoglPixelFormat defining the format of the image data
* in the given @buffer.
* @width: The width of the image data in the given @buffer.
* @height: The height of the image data in the given @buffer.
* @rowstride: The rowstride in bytes of the image data in the given @buffer.
* @offset: The offset into the given @buffer to the first pixel that
* should be considered part of the #CoglBitmap.
*
* Wraps some image data that has been uploaded into a #CoglBuffer as
* a #CoglBitmap. The data is not copied in this process.
*
* Return value: a #CoglBitmap encapsulating the given @buffer.
*
* Since: 1.8
* Stability: unstable
*/
CoglBitmap *
cogl_bitmap_new_from_buffer (CoglBuffer *buffer,
CoglPixelFormat format,
int width,
int height,
int rowstride,
int offset);
Change API so that CoglPixelBuffer no longer knows its w/h/format The idea is that CoglPixelBuffer should just be a buffer that can be used for pixel data and it has no idea about the details of any images that are stored in it. This is analogous to CoglAttributeBuffer which itself does not have any information about the attributes. When you want to use a pixel buffer you should create a CoglBitmap which points to a region of the attribute buffer and provides the extra needed information such as the width, height and format. That way it is also possible to use a single CoglPixelBuffer with multiple bitmaps. The changes that are made are: • cogl_pixel_buffer_new_with_size has been removed and in its place is cogl_bitmap_new_with_size. This will create a pixel buffer at the right size and rowstride for the given width/height/format and immediately create a single CoglBitmap to point into it. The old function had an out-parameter for the stride of the image but with the new API this should be queriable from the bitmap (although there is no function for this yet). • There is now a public cogl_pixel_buffer_new constructor. This takes a size in bytes and data pointer similarly to cogl_attribute_buffer_new. • cogl_texture_new_from_buffer has been removed. If you want to create a texture from a pixel buffer you should wrap it up in a bitmap first. There is already API to create a texture from a bitmap. This patch also does a bit of header juggling because cogl-context.h was including cogl-texture.h and cogl-framebuffer.h which were causing some circular dependencies when cogl-bitmap.h includes cogl-context.h. These weren't actually needed in cogl-context.h itself but a few other headers were relying on them being included so this adds the #includes where necessary. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-25 15:04:45 -05:00
/**
* cogl_bitmap_new_with_size:
* @context: A #CoglContext
* @width: width of the bitmap in pixels
* @height: height of the bitmap in pixels
* @format: the format of the pixels the array will store
*
* Creates a new #CoglBitmap with the given width, height and format.
* The initial contents of the bitmap are undefined.
*
* The data for the bitmap will be stored in a newly created
* #CoglPixelBuffer. You can get a pointer to the pixel buffer using
* cogl_bitmap_get_pixel_buffer(). The #CoglBuffer API can then be
* used to fill the bitmap with data.
*
* <note>Cogl will try its best to provide a hardware array you can
* map, write into and effectively do a zero copy upload when creating
* a texture from it with cogl_texture_new_from_bitmap(). For various
* reasons, such arrays are likely to have a stride larger than width
* * bytes_per_pixel. The user must take the stride into account when
* writing into it. The stride can be retrieved with
* cogl_bitmap_get_rowstride().</note>
*
* Return value: a #CoglPixelBuffer representing the newly created array or
* %NULL on failure
*
* Since: 1.10
* Stability: Unstable
*/
CoglBitmap *
cogl_bitmap_new_with_size (CoglContext *context,
unsigned int width,
unsigned int height,
CoglPixelFormat format);
/**
* cogl_bitmap_new_for_data:
* @context: A #CoglContext
* @width: The width of the bitmap.
* @height: The height of the bitmap.
* @format: The format of the pixel data.
* @rowstride: The rowstride of the bitmap (the number of bytes from
* the start of one row of the bitmap to the next).
* @data: A pointer to the data. The bitmap will take ownership of this data.
*
* Creates a bitmap using some existing data. The data is not copied
* so the application must keep the buffer alive for the lifetime of
* the #CoglBitmap. This can be used for example with
* cogl_framebuffer_read_pixels_into_bitmap() to read data directly
* into an application buffer with the specified rowstride.
*
* Return value: A new #CoglBitmap.
* Since: 1.10
* Stability: unstable
*/
CoglBitmap *
cogl_bitmap_new_for_data (CoglContext *context,
int width,
int height,
CoglPixelFormat format,
int rowstride,
guint8 *data);
/**
* cogl_bitmap_get_format:
* @bitmap: A #CoglBitmap
*
* Return value: the #CoglPixelFormat that the data for the bitmap is in.
* Since: 1.10
* Stability: unstable
*/
CoglPixelFormat
cogl_bitmap_get_format (CoglBitmap *bitmap);
/**
* cogl_bitmap_get_width:
* @bitmap: A #CoglBitmap
*
* Return value: the width of the bitmap
* Since: 1.10
* Stability: unstable
*/
int
cogl_bitmap_get_width (CoglBitmap *bitmap);
/**
* cogl_bitmap_get_height:
* @bitmap: A #CoglBitmap
*
* Return value: the height of the bitmap
* Since: 1.10
* Stability: unstable
*/
int
cogl_bitmap_get_height (CoglBitmap *bitmap);
/**
* cogl_bitmap_get_rowstride:
* @bitmap: A #CoglBitmap
*
* Return value: the rowstride of the bitmap. This is the number of
* bytes between the address of start of one row to the address of the
* next row in the image.
* Since: 1.10
* Stability: unstable
*/
int
cogl_bitmap_get_rowstride (CoglBitmap *bitmap);
/**
* cogl_bitmap_get_buffer:
* @bitmap: A #CoglBitmap
*
* Return value: the #CoglPixelBuffer that this buffer uses for
* storage. Note that if the bitmap was created with
* cogl_bitmap_new_from_file() then it will not actually be using a
* pixel buffer and this function will return %NULL.
* Stability: unstable
* Since: 1.10
*/
CoglPixelBuffer *
cogl_bitmap_get_buffer (CoglBitmap *bitmap);
#endif /* COGL_ENABLE_EXPERIMENTAL_API */
/**
* cogl_bitmap_get_size_from_file:
* @filename: the file to check
* @width: (out): return location for the bitmap width, or %NULL
* @height: (out): return location for the bitmap height, or %NULL
*
* Parses an image file enough to extract the width and height
* of the bitmap.
*
* Return value: %TRUE if the image was successfully parsed
*
* Since: 1.0
*/
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
gboolean
cogl_bitmap_get_size_from_file (const char *filename,
int *width,
int *height);
/**
* cogl_is_bitmap:
* @handle: a #CoglHandle for a bitmap
*
* Checks whether @handle is a #CoglHandle for a bitmap
*
* Return value: %TRUE if the passed handle represents a bitmap,
* and %FALSE otherwise
*
* Since: 1.0
*/
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
gboolean
cogl_is_bitmap (CoglHandle handle);
/**
* COGL_BITMAP_ERROR:
*
* #GError domain for bitmap errors.
*
* Since: 1.4
*/
#define COGL_BITMAP_ERROR (cogl_bitmap_error_quark ())
/**
* CoglBitmapError:
* @COGL_BITMAP_ERROR_FAILED: Generic failure code, something went
* wrong.
2010-12-22 04:42:41 -05:00
* @COGL_BITMAP_ERROR_UNKNOWN_TYPE: Unknown image type.
* @COGL_BITMAP_ERROR_CORRUPT_IMAGE: An image file was broken somehow.
*
* Error codes that can be thrown when performing bitmap
* operations. Note that gdk_pixbuf_new_from_file() can also throw
* errors directly from the underlying image loading library. For
* example, if GdkPixbuf is used then errors #GdkPixbufError<!-- -->s
* will be used directly.
*
* Since: 1.4
*/
typedef enum {
COGL_BITMAP_ERROR_FAILED,
COGL_BITMAP_ERROR_UNKNOWN_TYPE,
COGL_BITMAP_ERROR_CORRUPT_IMAGE
} CoglBitmapError;
GQuark cogl_bitmap_error_quark (void);
G_END_DECLS
#endif /* __COGL_BITMAP_H__ */