cairo/src/cairo-quartz-image-surface.c

   1 /* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */
   2 /* cairo - a vector graphics library with display and print output
   3  *
   4  * Copyright � 2008 Mozilla Corporation
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it either under the terms of the GNU Lesser General Public
   8  * License version 2.1 as published by the Free Software Foundation
   9  * (the "LGPL") or, at your option, under the terms of the Mozilla
  10  * Public License Version 1.1 (the "MPL"). If you do not alter this
  11  * notice, a recipient may use your version of this file under either
  12  * the MPL or the LGPL.
  13  *
  14  * You should have received a copy of the LGPL along with this library
  15  * in the file COPYING-LGPL-2.1; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  17  * You should have received a copy of the MPL along with this library
  18  * in the file COPYING-MPL-1.1
  19  *
  20  * The contents of this file are subject to the Mozilla Public License
  21  * Version 1.1 (the "License"); you may not use this file except in
  22  * compliance with the License. You may obtain a copy of the License at
  23  * http://www.mozilla.org/MPL/
  24  *
  25  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
  26  * OF ANY KIND, either express or implied. See the LGPL or the MPL for
  27  * the specific language governing rights and limitations.
  28  *
  29  * The Original Code is the cairo graphics library.
  30  *
  31  * The Initial Developer of the Original Code is Mozilla Corporation.
  32  *
  33  * Contributor(s):
  34  *      Vladimir Vukicevic <vladimir@mozilla.com>
  35  */
  36
  37 #include "cairoint.h"
  38
  39 #include "cairo-quartz-image.h"
  40 #include "cairo-quartz-private.h"
  41
  42 #define SURFACE_ERROR_NO_MEMORY (_cairo_surface_create_in_error(_cairo_error(CAIRO_STATUS_NO_MEMORY)))
  43 #define SURFACE_ERROR_TYPE_MISMATCH (_cairo_surface_create_in_error(_cairo_error(CAIRO_STATUS_SURFACE_TYPE_MISMATCH)))
  44 #define SURFACE_ERROR_INVALID_FORMAT (_cairo_surface_create_in_error(_cairo_error(CAIRO_STATUS_INVALID_FORMAT)))
  45
  46 static void
  47 DataProviderReleaseCallback (void *info, const void *data, size_t size)
  48 {
  49     cairo_surface_t *surface = (cairo_surface_t *) info;
  50     cairo_surface_destroy (surface);
  51 }
  52
  53 static cairo_surface_t *
  54 _cairo_quartz_image_surface_create_similar (void *asurface,
  55                                             cairo_content_t content,
  56                                             int width,
  57                                             int height)
  58 {
  59     cairo_surface_t *result;
  60     cairo_surface_t *isurf = cairo_image_surface_create (_cairo_format_from_content (content),
  61                                                          width,
  62                                                          height);
  63     if (cairo_surface_status(isurf))
  64         return isurf;
  65
  66     result = cairo_quartz_image_surface_create (isurf);
  67     cairo_surface_destroy (isurf);
  68
  69     return result;
  70 }
  71
  72 static cairo_status_t
  73 _cairo_quartz_image_surface_finish (void *asurface)
  74 {
  75     cairo_quartz_image_surface_t *surface = (cairo_quartz_image_surface_t *) asurface;
  76
  77     /* the imageSurface will be destroyed by the data provider's release callback */
  78     CGImageRelease (surface->image);
  79
  80     return CAIRO_STATUS_SUCCESS;
  81 }
  82
  83 static cairo_status_t
  84 _cairo_quartz_image_surface_acquire_source_image (void *asurface,
  85                                                   cairo_image_surface_t **image_out,
  86                                                   void **image_extra)
  87 {
  88     cairo_quartz_image_surface_t *surface = (cairo_quartz_image_surface_t *) asurface;
  89
  90     *image_out = surface->imageSurface;
  91     *image_extra = NULL;
  92
  93     return CAIRO_STATUS_SUCCESS;
  94 }
  95
  96 static cairo_status_t
  97 _cairo_quartz_image_surface_acquire_dest_image (void *asurface,
  98                                                 cairo_rectangle_int_t *interest_rect,
  99                                                 cairo_image_surface_t **image_out,
 100                                                 cairo_rectangle_int_t *image_rect,
 101                                                 void **image_extra)
 102 {
 103     cairo_quartz_image_surface_t *surface = (cairo_quartz_image_surface_t *) asurface;
 104
 105     *image_out = surface->imageSurface;
 106     *image_rect = surface->extents;
 107     *image_extra = NULL;
 108
 109     return CAIRO_STATUS_SUCCESS;
 110
 111 }
 112
 113 static cairo_int_status_t
 114 _cairo_quartz_image_surface_get_extents (void *asurface,
 115                                          cairo_rectangle_int_t *extents)
 116 {
 117     cairo_quartz_image_surface_t *surface = (cairo_quartz_image_surface_t *) asurface;
 118
 119     *extents = surface->extents;
 120
 121     return CAIRO_STATUS_SUCCESS;
 122 }
 123
 124 /* we assume some drawing happened to the image buffer; make sure it's
 125  * represented in the CGImage on flush()
 126  */
 127
 128 static cairo_status_t
 129 _cairo_quartz_image_surface_flush (void *asurface)
 130 {
 131     cairo_quartz_image_surface_t *surface = (cairo_quartz_image_surface_t *) asurface;
 132     CGImageRef oldImage = surface->image;
 133     CGImageRef newImage = NULL;
 134
 135     /* To be released by the ReleaseCallback */
 136     cairo_surface_reference ((cairo_surface_t*) surface->imageSurface);
 137
 138     newImage = _cairo_quartz_create_cgimage (surface->imageSurface->format,
 139                                              surface->imageSurface->width,
 140                                              surface->imageSurface->height,
 141                                              surface->imageSurface->stride,
 142                                              surface->imageSurface->data,
 143                                              TRUE,
 144                                              NULL,
 145                                              DataProviderReleaseCallback,
 146                                              surface->imageSurface);
 147
 148     surface->image = newImage;
 149     CGImageRelease (oldImage);
 150
 151     return CAIRO_STATUS_SUCCESS;
 152 }
 153
 154 static const cairo_surface_backend_t cairo_quartz_image_surface_backend = {
 155     CAIRO_SURFACE_TYPE_QUARTZ_IMAGE,
 156     _cairo_quartz_image_surface_create_similar,
 157     _cairo_quartz_image_surface_finish,
 158     _cairo_quartz_image_surface_acquire_source_image,
 159     NULL, /* release_source_image */
 160     _cairo_quartz_image_surface_acquire_dest_image,
 161     NULL, /* release_dest_image */
 162     NULL, /* clone_similar */
 163     NULL, /* composite */
 164     NULL, /* fill_rectangles */
 165     NULL, /* composite_trapezoids */
 166     NULL, /* copy_page */
 167     NULL, /* show_page */
 168     NULL, /* set_clip_region */
 169     NULL, /* intersect_clip_path */
 170     _cairo_quartz_image_surface_get_extents,
 171     NULL, /* old_show_glyphs */
 172     NULL, /* get_font_options */
 173     _cairo_quartz_image_surface_flush,
 174     NULL, /* mark_dirty_rectangle */
 175     NULL, /* scaled_font_fini */
 176     NULL, /* scaled_glyph_fini */
 177
 178     NULL, /* paint */
 179     NULL, /* mask */
 180     NULL, /* stroke */
 181     NULL, /* fill */
 182     NULL, /* surface_show_glyphs */
 183     NULL, /* snapshot */
 184     NULL, /* is_similar */
 185     NULL, /* reset */
 186     NULL  /* fill_stroke */
 187
 188 };
 189
 190 /**
 191  * cairo_quartz_image_surface_create
 192  * @surface: a cairo image surface to wrap with a quartz image surface
 193  *
 194  * Creates a Quartz surface backed by a CGImageRef that references the
 195  * given image surface. The resulting surface can be rendered quickly
 196  * when used as a source when rendering to a #cairo_quartz_surface.  If
 197  * the data in the image surface is ever updated, cairo_surface_flush()
 198  * must be called on the #cairo_quartz_image_surface to ensure that the
 199  * CGImageRef refers to the updated data.
 200  *
 201  * Return value: the newly created surface.
 202  *
 203  * Since: 1.6
 204  */
 205 cairo_surface_t *
 206 cairo_quartz_image_surface_create (cairo_surface_t *surface)
 207 {
 208     cairo_quartz_image_surface_t *qisurf;
 209
 210     CGImageRef image;
 211
 212     cairo_image_surface_t *image_surface;
 213     int width, height, stride;
 214     cairo_format_t format;
 215     unsigned char *data;
 216
 217     if (cairo_surface_get_type(surface) != CAIRO_SURFACE_TYPE_IMAGE)
 218         return SURFACE_ERROR_TYPE_MISMATCH;
 219
 220     image_surface = (cairo_image_surface_t*) surface;
 221     width = image_surface->width;
 222     height = image_surface->height;
 223     stride = image_surface->stride;
 224     format = image_surface->format;
 225     data = image_surface->data;
 226
 227     if (!_cairo_quartz_verify_surface_size(width, height))
 228         return SURFACE_ERROR_NO_MEMORY;
 229
 230     if (width == 0 || height == 0)
 231         return SURFACE_ERROR_NO_MEMORY;
 232
 233     if (format != CAIRO_FORMAT_ARGB32 && format != CAIRO_FORMAT_RGB24)
 234         return SURFACE_ERROR_INVALID_FORMAT;
 235
 236     qisurf = malloc(sizeof(cairo_quartz_image_surface_t));
 237     if (qisurf == NULL)
 238         return SURFACE_ERROR_NO_MEMORY;
 239
 240     memset (qisurf, 0, sizeof(cairo_quartz_image_surface_t));
 241
 242     /* In case the create_cgimage fails, this ref will
 243      * be released via the callback (which will be called in
 244      * case of failure.)
 245      */
 246     cairo_surface_reference (surface);
 247
 248     image = _cairo_quartz_create_cgimage (format,
 249                                           width, height,
 250                                           stride,
 251                                           data,
 252                                           TRUE,
 253                                           NULL,
 254                                           DataProviderReleaseCallback,
 255                                           image_surface);
 256
 257     if (!image) {
 258         free (qisurf);
 259         return SURFACE_ERROR_NO_MEMORY;
 260     }
 261
 262     _cairo_surface_init (&qisurf->base,
 263                          &cairo_quartz_image_surface_backend,
 264                          _cairo_content_from_format (format));
 265
 266     qisurf->extents.x = qisurf->extents.y = 0;
 267     qisurf->extents.width = width;
 268     qisurf->extents.height = height;
 269
 270     qisurf->image = image;
 271     qisurf->imageSurface = image_surface;
 272
 273     return &qisurf->base;
 274 }
 275
 276
 277 cairo_surface_t *
 278 cairo_quartz_image_surface_get_image (cairo_surface_t *asurface)
 279 {
 280     cairo_quartz_image_surface_t *surface = (cairo_quartz_image_surface_t*) asurface;
 281
 282     if (cairo_surface_get_type(asurface) != CAIRO_SURFACE_TYPE_QUARTZ_IMAGE)
 283         return NULL;
 284
 285     return (cairo_surface_t*) surface->imageSurface;
 286 }