brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
8f8b05f0e5
mutter/cogl/cogl-pixel-array.c

149 lines
4.1 KiB
C
Raw Normal View History

cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2010 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
Remove mentions of the FSF address Since using addresses that might change is something that finally the FSF acknowledge as a plausible scenario (after changing address twice), the license blurb in the source files should use the URI for getting the license in case the library did not come with it. Not that URIs cannot possibly change, but at least it's easier to set up a redirection at the same place. As a side note: this commit closes the oldes bug in Clutter's bug report tool. http://bugzilla.openedhand.com/show_bug.cgi?id=521
2010-03-01 12:56:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
*
* Authors:
* Damien Lespiau <damien.lespiau@intel.com>
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 22:46:03 +00:00
* Robert Bragg <robert@linux.intel.com>
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
*/
/* For an overview of the functionality implemented here, please see
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 22:46:03 +00:00
* cogl-pixel-array.h, which contains the gtk-doc section overview for the
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
* Pixel Buffers API.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <string.h>
#include <glib.h>
#include "cogl.h"
#include "cogl-internal.h"
#include "cogl-util.h"
#include "cogl-context.h"
pixel-buffer: Replace CoglHandle with CoglPixelBuffer * One more file converted to stop using CoglHandle re:a8c8cbee513
2010-07-03 19:24:36 +00:00
#include "cogl-object.h"
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 22:46:03 +00:00
#include "cogl-pixel-array-private.h"
#include "cogl-pixel-array.h"
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
/*
* GL/GLES compatibility defines for the buffer API:
*/
#if defined (HAVE_COGL_GL)
#define glGenBuffers ctx->drv.pf_glGenBuffers
#define glBindBuffer ctx->drv.pf_glBindBuffer
#define glBufferData ctx->drv.pf_glBufferData
#define glBufferSubData ctx->drv.pf_glBufferSubData
#define glGetBufferSubData ctx->drv.pf_glGetBufferSubData
#define glDeleteBuffers ctx->drv.pf_glDeleteBuffers
#define glMapBuffer ctx->drv.pf_glMapBuffer
#define glUnmapBuffer ctx->drv.pf_glUnmapBuffer
#ifndef GL_PIXEL_UNPACK_BUFFER
#define GL_PIXEL_UNPACK_BUFFER GL_PIXEL_UNPACK_BUFFER_ARB
#endif
#ifndef GL_PIXEL_PACK_BUFFER
#define GL_PIXEL_PACK_BUFFER GL_PIXEL_PACK_BUFFER_ARB
#endif
#endif
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-10 01:57:32 +00:00
static void
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 22:46:03 +00:00
_cogl_pixel_array_free (CoglPixelArray *buffer);
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 22:46:03 +00:00
COGL_BUFFER_DEFINE (PixelArray, pixel_array)
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
pixel-array: Only allow allocation of arrays with a 2D size This removes cogl_pixel_array_new which just took a size in bytes. Without the image size and pixel format then the driver often doesn't have enough information to allocate optimal GPU memory that can be textured from directly. This is because GPUs often have ways to spatially alter the layout of a texture to improve cache access patterns which may require special alignment and padding dependant in the images width, height and bpp. Although currently we are limited by OpenGL because it doesn't let us pass on the width and height when allocating a PBO, the hope is that we can define a better extension at some point.
2010-07-03 23:49:31 +00:00
static CoglPixelArray *
_cogl_pixel_array_new (unsigned int size)
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
{
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 22:46:03 +00:00
CoglPixelArray *pixel_array = g_slice_new0 (CoglPixelArray);
CoglBuffer *buffer = COGL_BUFFER (pixel_array);
cogl-buffer: Move malloc fallback logic into CoglBuffer Since we'll want to share the fallback logic with CoglVertexArray this moves the malloc based fallback (for when OpenGL doesn't support vertex or pixel buffer objects) into cogl-buffer.c.
2010-07-06 00:21:43 +00:00
gboolean use_malloc;
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
_COGL_GET_CONTEXT (ctx, COGL_INVALID_HANDLE);
cogl-buffer: Move malloc fallback logic into CoglBuffer Since we'll want to share the fallback logic with CoglVertexArray this moves the malloc based fallback (for when OpenGL doesn't support vertex or pixel buffer objects) into cogl-buffer.c.
2010-07-06 00:21:43 +00:00
if (!cogl_features_available (COGL_FEATURE_PBOS))
use_malloc = TRUE;
else
use_malloc = FALSE;
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
/* parent's constructor */
_cogl_buffer_initialize (buffer,
size,
cogl-buffer: Move malloc fallback logic into CoglBuffer Since we'll want to share the fallback logic with CoglVertexArray this moves the malloc based fallback (for when OpenGL doesn't support vertex or pixel buffer objects) into cogl-buffer.c.
2010-07-06 00:21:43 +00:00
use_malloc,
cogl-buffer: Track the last used bind target in CoglBuffer This makes CoglBuffer track the last used bind target as a private property. This is later used when binding a buffer to map instead of always using the PIXEL_UNPACK target. This also adds some additional sanity checks that code doesn't try to nest binds to the same target or bind a buffer to multiple targets at the same time.
2010-07-05 22:24:34 +00:00
COGL_BUFFER_BIND_TARGET_PIXEL_UNPACK,
cogl-buffer: Use TEXTURE as the only value for CoglBufferUsageHint We should try to use more explicit defines than GL for our hints. For now we only support using a CoglBuffer to generate textures.
2010-02-08 17:11:43 +00:00
COGL_BUFFER_USAGE_HINT_TEXTURE,
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
COGL_BUFFER_UPDATE_HINT_STATIC);
/* return COGL_INVALID_HANDLE; */
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 22:46:03 +00:00
return _cogl_pixel_array_object_new (pixel_array);
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
}
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 22:46:03 +00:00
CoglPixelArray *
pixel-array: rename new_from_size to new_with_size It is more in keeping with other coding conventions in Cogl to use new "with" size instead of new "from" size.
2010-07-03 23:45:12 +00:00
cogl_pixel_array_new_with_size (unsigned int width,
unsigned int height,
CoglPixelFormat format,
unsigned int *rowstride)
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
{
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 22:46:03 +00:00
CoglPixelArray *buffer;
CoglPixelArray *pixel_array;
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-10 01:57:32 +00:00
unsigned int stride;
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
/* creating a buffer to store "any" format does not make sense */
if (G_UNLIKELY (format == COGL_PIXEL_FORMAT_ANY))
return COGL_INVALID_HANDLE;
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 22:46:03 +00:00
/* for now we fallback to cogl_pixel_array_new, later, we could ask
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
* libdrm a tiled buffer for instance */
stride = width * _cogl_get_format_bpp (format);
if (rowstride)
*rowstride = stride;
pixel-array: Only allow allocation of arrays with a 2D size This removes cogl_pixel_array_new which just took a size in bytes. Without the image size and pixel format then the driver often doesn't have enough information to allocate optimal GPU memory that can be textured from directly. This is because GPUs often have ways to spatially alter the layout of a texture to improve cache access patterns which may require special alignment and padding dependant in the images width, height and bpp. Although currently we are limited by OpenGL because it doesn't let us pass on the width and height when allocating a PBO, the hope is that we can define a better extension at some point.
2010-07-03 23:49:31 +00:00
buffer = _cogl_pixel_array_new (height * stride);
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
if (G_UNLIKELY (buffer == COGL_INVALID_HANDLE))
return COGL_INVALID_HANDLE;
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 22:46:03 +00:00
pixel_array = COGL_PIXEL_ARRAY (buffer);
pixel_array->width = width;
pixel_array->height = height;
pixel_array->format = format;
pixel_array->stride = stride;
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
return buffer;
}
static void
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 22:46:03 +00:00
_cogl_pixel_array_free (CoglPixelArray *buffer)
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
/* parent's destructor */
_cogl_buffer_fini (COGL_BUFFER (buffer));
rename CoglPixelBuffer to CoglPixelArray This renames CoglPixelBuffer to CoglPixelArray to be consistent with the new CoglVertexArray API.
2010-07-03 22:46:03 +00:00
g_slice_free (CoglPixelArray, buffer);
cogl-pixel-buffer: add a pixel buffer object class This subclass of CoglBuffer aims at wrapping PBOs or other system surfaces like DRM buffer objects. Two constructors are available: cogl_pixel_buffer_new() with a size when you only care about the size of the buffer (such a buffer can be used to store several texture data such as the three planes of a I420 frame). cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and an underlying surface, with the possibility of having access to a low level memory buffer that may have a stride.
2010-01-10 18:04:29 +00:00
}
Reference in New Issue Copy Permalink