brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
63db64f426
mutter/cogl/cogl-pixel-buffer.c

105 lines
2.7 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 13:04:29 -05: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 07:56:10 -05: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 13:04:29 -05: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 18:46:03 -04: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 13:04:29 -05:00
*/
/* For an overview of the functionality implemented here, please see
Rename CoglPixelArray to CoglPixelBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to strongly imply a relationship between CoglBuffers and CoglPixelBuffers and be consistent with the CoglAttributeBuffer and CoglIndexBuffer APIs.
2011-03-02 10:19:57 -05:00
* cogl-buffer-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 13:04:29 -05:00
* Pixel Buffers API.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <string.h>
#include <glib.h>
moves and renames _cogl_get_format_bpp This moves _cogl_get_format_bpp from cogl-bitmap.c to cogl.c and renames it to _cogl_pixel_format_get_bytes_per_pixel. This makes it clearer that it doesn't return bits per pixel and makes the naming consistent with other cogl api. The prototype has been moved to cogl-private.h since it seems we should be aiming to get rid of cogl-internal.h at some point. The patch also adds a simple gtk-doc comment since we might want to make this api public. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-13 18:02:04 -05:00
#include "cogl-private.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 13:04:29 -05:00
#include "cogl-util.h"
cogl: rename cogl-context.h cogl-context-private.h Since we plan to add public cogl_context_* API we need to rename the current cogl-context.h which contains private member details.
2010-11-04 18:25:52 -04:00
#include "cogl-context-private.h"
pixel-buffer: Replace CoglHandle with CoglPixelBuffer * One more file converted to stop using CoglHandle re:a8c8cbee513
2010-07-03 15:24:36 -04:00
#include "cogl-object.h"
Rename CoglPixelArray to CoglPixelBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to strongly imply a relationship between CoglBuffers and CoglPixelBuffers and be consistent with the CoglAttributeBuffer and CoglIndexBuffer APIs.
2011-03-02 10:19:57 -05:00
#include "cogl-pixel-buffer-private.h"
#include "cogl-pixel-buffer.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 13:04:29 -05:00
/*
* GL/GLES compatibility defines for the buffer API:
*/
#if defined (HAVE_COGL_GL)
#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-09 20:57:32 -05:00
static void
Rename CoglPixelArray to CoglPixelBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to strongly imply a relationship between CoglBuffers and CoglPixelBuffers and be consistent with the CoglAttributeBuffer and CoglIndexBuffer APIs.
2011-03-02 10:19:57 -05:00
_cogl_pixel_buffer_free (CoglPixelBuffer *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 13:04:29 -05:00
Rename CoglPixelArray to CoglPixelBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to strongly imply a relationship between CoglBuffers and CoglPixelBuffers and be consistent with the CoglAttributeBuffer and CoglIndexBuffer APIs.
2011-03-02 10:19:57 -05:00
COGL_BUFFER_DEFINE (PixelBuffer, pixel_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 13:04:29 -05:00
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
CoglPixelBuffer *
cogl_pixel_buffer_new (CoglContext *context,
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
size_t size,
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
const void *data)
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 13:04:29 -05:00
{
Rename CoglPixelArray to CoglPixelBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to strongly imply a relationship between CoglBuffers and CoglPixelBuffers and be consistent with the CoglAttributeBuffer and CoglIndexBuffer APIs.
2011-03-02 10:19:57 -05:00
CoglPixelBuffer *pixel_buffer = g_slice_new0 (CoglPixelBuffer);
CoglBuffer *buffer = COGL_BUFFER (pixel_buffer);
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-05 20:21:43 -04:00
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 13:04:29 -05:00
/* parent's constructor */
_cogl_buffer_initialize (buffer,
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
context,
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 13:04:29 -05:00
size,
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 18:24:34 -04: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 12:11:43 -05: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 13:04:29 -05:00
COGL_BUFFER_UPDATE_HINT_STATIC);
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_pixel_buffer_object_new (pixel_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 13:04:29 -05:00
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
if (data)
cogl_buffer_set_data (COGL_BUFFER (pixel_buffer),
0,
data,
size);
return pixel_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 13:04:29 -05:00
}
static void
Rename CoglPixelArray to CoglPixelBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to strongly imply a relationship between CoglBuffers and CoglPixelBuffers and be consistent with the CoglAttributeBuffer and CoglIndexBuffer APIs.
2011-03-02 10:19:57 -05:00
_cogl_pixel_buffer_free (CoglPixelBuffer *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 13:04:29 -05:00
{
/* parent's destructor */
_cogl_buffer_fini (COGL_BUFFER (buffer));
Rename CoglPixelArray to CoglPixelBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to strongly imply a relationship between CoglBuffers and CoglPixelBuffers and be consistent with the CoglAttributeBuffer and CoglIndexBuffer APIs.
2011-03-02 10:19:57 -05:00
g_slice_free (CoglPixelBuffer, 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 13:04:29 -05:00
}
Reference in New Issue Copy Permalink