mirror of
https://github.com/brl/mutter.git
synced 2024-12-28 05:42:14 +00:00
a1952a25ad
Since 67cad9c0 and f7735e141a the bitmap allocation and mapping functions now take an extra error argument. The quartz image backend was missed in this update so Cogl would fail to compile if --enable-quartz-image is used. https://bugzilla.gnome.org/show_bug.cgi?id=696730 Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 1827965befccf331b0787f71cb191d370640a9de)
469 lines
13 KiB
C
469 lines
13 KiB
C
/*
|
|
* 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/>.
|
|
*
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "cogl-util.h"
|
|
#include "cogl-bitmap-private.h"
|
|
#include "cogl-context-private.h"
|
|
#include "cogl-private.h"
|
|
#include "cogl-error-private.h"
|
|
|
|
#include <string.h>
|
|
|
|
#ifdef USE_QUARTZ
|
|
#include <ApplicationServices/ApplicationServices.h>
|
|
#elif defined(USE_GDKPIXBUF)
|
|
#include <gdk-pixbuf/gdk-pixbuf.h>
|
|
#endif
|
|
|
|
#ifdef USE_QUARTZ
|
|
|
|
CoglBool
|
|
_cogl_bitmap_get_size_from_file (const char *filename,
|
|
int *width,
|
|
int *height)
|
|
{
|
|
if (width)
|
|
*width = 0;
|
|
|
|
if (height)
|
|
*height = 0;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* the error does not contain the filename as the caller already has it */
|
|
CoglBitmap *
|
|
_cogl_bitmap_from_file (CoglContext *ctx,
|
|
const char *filename,
|
|
CoglError **error)
|
|
{
|
|
CFURLRef url;
|
|
CGImageSourceRef image_source;
|
|
CGImageRef image;
|
|
int save_errno;
|
|
CFStringRef type;
|
|
size_t width, height, rowstride;
|
|
uint8_t *out_data;
|
|
CGColorSpaceRef color_space;
|
|
CGContextRef bitmap_context;
|
|
CoglBitmap *bmp;
|
|
|
|
url = CFURLCreateFromFileSystemRepresentation (NULL,
|
|
(guchar *) filename,
|
|
strlen (filename),
|
|
false);
|
|
image_source = CGImageSourceCreateWithURL (url, NULL);
|
|
save_errno = errno;
|
|
CFRelease (url);
|
|
|
|
if (image_source == NULL)
|
|
{
|
|
/* doesn't exist, not readable, etc. */
|
|
_cogl_set_error_literal (error,
|
|
COGL_BITMAP_ERROR,
|
|
COGL_BITMAP_ERROR_FAILED,
|
|
g_strerror (save_errno));
|
|
return NULL;
|
|
}
|
|
|
|
/* Unknown images would be cleanly caught as zero width/height below, but try
|
|
* to provide better error message
|
|
*/
|
|
type = CGImageSourceGetType (image_source);
|
|
if (type == NULL)
|
|
{
|
|
CFRelease (image_source);
|
|
_cogl_set_error_literal (error,
|
|
COGL_BITMAP_ERROR,
|
|
COGL_BITMAP_ERROR_UNKNOWN_TYPE,
|
|
"Unknown image type");
|
|
return NULL;
|
|
}
|
|
|
|
CFRelease (type);
|
|
|
|
image = CGImageSourceCreateImageAtIndex (image_source, 0, NULL);
|
|
CFRelease (image_source);
|
|
|
|
width = CGImageGetWidth (image);
|
|
height = CGImageGetHeight (image);
|
|
if (width == 0 || height == 0)
|
|
{
|
|
/* incomplete or corrupt */
|
|
CFRelease (image);
|
|
_cogl_set_error_literal (error,
|
|
COGL_BITMAP_ERROR,
|
|
COGL_BITMAP_ERROR_CORRUPT_IMAGE,
|
|
"Image has zero width or height");
|
|
return NULL;
|
|
}
|
|
|
|
/* allocate buffer big enough to hold pixel data */
|
|
bmp = _cogl_bitmap_new_with_malloc_buffer (ctx,
|
|
width, height,
|
|
COGL_PIXEL_FORMAT_ARGB_8888,
|
|
error);
|
|
if (bmp == NULL)
|
|
{
|
|
CFRelease (image);
|
|
return NULL;
|
|
}
|
|
rowstride = cogl_bitmap_get_rowstride (bmp);
|
|
out_data = _cogl_bitmap_map (bmp,
|
|
COGL_BUFFER_ACCESS_WRITE,
|
|
COGL_BUFFER_MAP_HINT_DISCARD,
|
|
error);
|
|
if (out_data == NULL)
|
|
{
|
|
cogl_object_unref (bmp);
|
|
CFRelease (image);
|
|
return NULL;
|
|
}
|
|
|
|
/* render to buffer */
|
|
color_space = CGColorSpaceCreateWithName (kCGColorSpaceGenericRGB);
|
|
bitmap_context = CGBitmapContextCreate (out_data,
|
|
width, height, 8,
|
|
rowstride, color_space,
|
|
kCGImageAlphaPremultipliedFirst);
|
|
CGColorSpaceRelease (color_space);
|
|
|
|
CGContextSetBlendMode (bitmap_context, kCGBlendModeCopy);
|
|
|
|
{
|
|
const CGRect rect = {{0, 0}, {width, height}};
|
|
|
|
CGContextDrawImage (bitmap_context, rect, image);
|
|
}
|
|
|
|
CGImageRelease (image);
|
|
CGContextRelease (bitmap_context);
|
|
|
|
_cogl_bitmap_unmap (bmp);
|
|
|
|
/* store bitmap info */
|
|
return bmp;
|
|
}
|
|
|
|
#elif defined(USE_GDKPIXBUF)
|
|
|
|
CoglBool
|
|
_cogl_bitmap_get_size_from_file (const char *filename,
|
|
int *width,
|
|
int *height)
|
|
{
|
|
_COGL_RETURN_VAL_IF_FAIL (filename != NULL, FALSE);
|
|
|
|
if (gdk_pixbuf_get_file_info (filename, width, height) != NULL)
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
CoglBitmap *
|
|
_cogl_bitmap_from_file (CoglContext *ctx,
|
|
const char *filename,
|
|
CoglError **error)
|
|
{
|
|
static CoglUserDataKey pixbuf_key;
|
|
GdkPixbuf *pixbuf;
|
|
CoglBool has_alpha;
|
|
GdkColorspace color_space;
|
|
CoglPixelFormat pixel_format;
|
|
int width;
|
|
int height;
|
|
int rowstride;
|
|
int bits_per_sample;
|
|
int n_channels;
|
|
CoglBitmap *bmp;
|
|
GError *glib_error = NULL;
|
|
|
|
/* Load from file using GdkPixbuf */
|
|
pixbuf = gdk_pixbuf_new_from_file (filename, &glib_error);
|
|
if (pixbuf == NULL)
|
|
{
|
|
_cogl_propagate_gerror (error, glib_error);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Get pixbuf properties */
|
|
has_alpha = gdk_pixbuf_get_has_alpha (pixbuf);
|
|
color_space = gdk_pixbuf_get_colorspace (pixbuf);
|
|
width = gdk_pixbuf_get_width (pixbuf);
|
|
height = gdk_pixbuf_get_height (pixbuf);
|
|
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
|
|
bits_per_sample = gdk_pixbuf_get_bits_per_sample (pixbuf);
|
|
n_channels = gdk_pixbuf_get_n_channels (pixbuf);
|
|
|
|
/* According to current docs this should be true and so
|
|
* the translation to cogl pixel format below valid */
|
|
g_assert (bits_per_sample == 8);
|
|
|
|
if (has_alpha)
|
|
g_assert (n_channels == 4);
|
|
else
|
|
g_assert (n_channels == 3);
|
|
|
|
/* Translate to cogl pixel format */
|
|
switch (color_space)
|
|
{
|
|
case GDK_COLORSPACE_RGB:
|
|
/* The only format supported by GdkPixbuf so far */
|
|
pixel_format = has_alpha ?
|
|
COGL_PIXEL_FORMAT_RGBA_8888 :
|
|
COGL_PIXEL_FORMAT_RGB_888;
|
|
break;
|
|
|
|
default:
|
|
/* Ouch, spec changed! */
|
|
g_object_unref (pixbuf);
|
|
return FALSE;
|
|
}
|
|
|
|
/* We just use the data directly from the pixbuf so that we don't
|
|
have to copy to a seperate buffer. Note that Cogl is expected not
|
|
to read past the end of bpp*width on the last row even if the
|
|
rowstride is much larger so we don't need to worry about
|
|
GdkPixbuf's semantics that it may under-allocate the buffer. */
|
|
bmp = cogl_bitmap_new_for_data (ctx,
|
|
width,
|
|
height,
|
|
pixel_format,
|
|
rowstride,
|
|
gdk_pixbuf_get_pixels (pixbuf));
|
|
|
|
cogl_object_set_user_data (COGL_OBJECT (bmp),
|
|
&pixbuf_key,
|
|
pixbuf,
|
|
g_object_unref);
|
|
|
|
return bmp;
|
|
}
|
|
|
|
#else
|
|
|
|
#include "stb_image.c"
|
|
|
|
CoglBool
|
|
_cogl_bitmap_get_size_from_file (const char *filename,
|
|
int *width,
|
|
int *height)
|
|
{
|
|
if (width)
|
|
*width = 0;
|
|
|
|
if (height)
|
|
*height = 0;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* stb_image.c supports an STBI_grey_alpha format which we don't have
|
|
* a corresponding CoglPixelFormat for so as a special case we
|
|
* convert this to rgba8888.
|
|
*
|
|
* If we have a use case where this is an important format to consider
|
|
* then it could be worth adding a corresponding CoglPixelFormat
|
|
* instead.
|
|
*/
|
|
static uint8_t *
|
|
convert_ra_88_to_rgba_8888 (uint8_t *pixels,
|
|
int width,
|
|
int height)
|
|
{
|
|
int x, y;
|
|
uint8_t *buf;
|
|
size_t in_stride = width * 2;
|
|
size_t out_stride = width * 4;
|
|
|
|
buf = malloc (width * height * 4);
|
|
if (buf)
|
|
return NULL;
|
|
|
|
for (y = 0; y < height; y++)
|
|
for (x = 0; x < width; x++)
|
|
{
|
|
uint8_t *src = pixels + in_stride * y + 2 * x;
|
|
uint8_t *dst = buf + out_stride * y + 4 * x;
|
|
|
|
dst[0] = src[0];
|
|
dst[1] = src[0];
|
|
dst[2] = src[0];
|
|
dst[3] = src[1];
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
static CoglBitmap *
|
|
_cogl_bitmap_new_from_stb_pixels (CoglContext *ctx,
|
|
uint8_t *pixels,
|
|
int stb_pixel_format,
|
|
int width,
|
|
int height,
|
|
CoglError **error)
|
|
{
|
|
static CoglUserDataKey bitmap_data_key;
|
|
CoglBitmap *bmp;
|
|
CoglPixelFormat cogl_format;
|
|
size_t stride;
|
|
|
|
if (pixels == NULL)
|
|
{
|
|
_cogl_set_error_literal (error,
|
|
COGL_BITMAP_ERROR,
|
|
COGL_BITMAP_ERROR_FAILED,
|
|
"Failed to load image with stb image library");
|
|
return NULL;
|
|
}
|
|
|
|
switch (stb_pixel_format)
|
|
{
|
|
case STBI_grey:
|
|
cogl_format = COGL_PIXEL_FORMAT_A_8;
|
|
break;
|
|
case STBI_grey_alpha:
|
|
{
|
|
uint8_t *tmp = pixels;
|
|
|
|
pixels = convert_ra_88_to_rgba_8888 (pixels, width, height);
|
|
free (tmp);
|
|
|
|
if (!pixels)
|
|
{
|
|
_cogl_set_error_literal (error,
|
|
COGL_BITMAP_ERROR,
|
|
COGL_BITMAP_ERROR_FAILED,
|
|
"Failed to alloc memory to convert "
|
|
"gray_alpha to rgba8888");
|
|
return NULL;
|
|
}
|
|
|
|
cogl_format = COGL_PIXEL_FORMAT_RGBA_8888;
|
|
break;
|
|
}
|
|
case STBI_rgb:
|
|
cogl_format = COGL_PIXEL_FORMAT_RGB_888;
|
|
break;
|
|
case STBI_rgb_alpha:
|
|
cogl_format = COGL_PIXEL_FORMAT_RGBA_8888;
|
|
break;
|
|
|
|
default:
|
|
g_warn_if_reached ();
|
|
return NULL;
|
|
}
|
|
|
|
stride = width * _cogl_pixel_format_get_bytes_per_pixel (cogl_format);
|
|
|
|
/* Store bitmap info */
|
|
bmp = cogl_bitmap_new_for_data (ctx,
|
|
width, height,
|
|
cogl_format,
|
|
stride,
|
|
pixels);
|
|
|
|
/* Register a destroy function so the pixel data will be freed
|
|
automatically when the bitmap object is destroyed */
|
|
cogl_object_set_user_data (COGL_OBJECT (bmp), &bitmap_data_key, pixels, free);
|
|
|
|
return bmp;
|
|
}
|
|
|
|
CoglBitmap *
|
|
_cogl_bitmap_from_file (CoglContext *ctx,
|
|
const char *filename,
|
|
CoglError **error)
|
|
{
|
|
int stb_pixel_format;
|
|
int width;
|
|
int height;
|
|
uint8_t *pixels;
|
|
|
|
pixels = stbi_load (filename,
|
|
&width, &height, &stb_pixel_format,
|
|
STBI_default);
|
|
|
|
return _cogl_bitmap_new_from_stb_pixels (ctx, pixels, stb_pixel_format,
|
|
width, height,
|
|
error);
|
|
}
|
|
|
|
#ifdef COGL_HAS_ANDROID_SUPPORT
|
|
CoglBitmap *
|
|
_cogl_android_bitmap_new_from_asset (CoglContext *ctx,
|
|
AAssetManager *manager,
|
|
const char *filename,
|
|
CoglError **error)
|
|
{
|
|
AAsset *asset;
|
|
const void *data;
|
|
off_t len;
|
|
int stb_pixel_format;
|
|
int width;
|
|
int height;
|
|
uint8_t *pixels;
|
|
CoglBitmap *bmp;
|
|
|
|
asset = AAssetManager_open (manager, filename, AASSET_MODE_BUFFER);
|
|
if (!asset)
|
|
{
|
|
_cogl_set_error_literal (error,
|
|
COGL_BITMAP_ERROR,
|
|
COGL_BITMAP_ERROR_FAILED,
|
|
"Failed to open asset");
|
|
return NULL;
|
|
}
|
|
|
|
data = AAsset_getBuffer (asset);
|
|
if (!data)
|
|
{
|
|
_cogl_set_error_literal (error,
|
|
COGL_BITMAP_ERROR,
|
|
COGL_BITMAP_ERROR_FAILED,
|
|
"Failed to ::getBuffer from asset");
|
|
return NULL;
|
|
}
|
|
|
|
len = AAsset_getLength (asset);
|
|
|
|
pixels = stbi_load_from_memory (data, len,
|
|
&width, &height,
|
|
&stb_pixel_format, STBI_default);
|
|
|
|
bmp = _cogl_bitmap_new_from_stb_pixels (ctx, pixels, stb_pixel_format,
|
|
width, height,
|
|
error);
|
|
|
|
AAsset_close (asset);
|
|
|
|
return bmp;
|
|
}
|
|
#endif
|
|
|
|
#endif
|