Index: configure.in =================================================================== RCS file: /cvs/cairo/cairo/configure.in,v retrieving revision 1.82 diff -u -w -r1.82 configure.in --- configure.in 6 Feb 2005 01:17:19 -0000 1.82 +++ configure.in 11 Feb 2005 18:06:17 -0000 @@ -47,6 +47,30 @@ dnl =========================================================================== +AC_ARG_ENABLE(directfb, + [ --disable-directfb Disable cairo's drectfb backend], + [use_directfb=$enableval], [use_directfb=yes]) + +if test "x$use_directfb" = "xyes"; then + PKG_CHECK_MODULES(DIRECTFB, directfb, [use_directfb=yes], [ + use_directfb="no (requires directfb http://www.directfb.org)"]) +fi + +if test "x$use_directfb" != "xyes"; then + DIRECTFB_SURFACE_FEATURE=CAIRO_HAS_NO_DIRECTFB_SURFACE + AM_CONDITIONAL(CAIRO_HAS_DIRECTFB_SURFACE, false) +else + DIRECTFB_SURFACE_FEATURE=CAIRO_HAS_DIRECTFB_SURFACE + AM_CONDITIONAL(CAIRO_HAS_DIRECTFB_SURFACE, true) +fi + +CAIRO_CFLAGS="$CAIRO_CFLAGS $DIRECTFB_CFLAGS" +CAIRO_LIBS="$CAIRO_LIBS $DIRECTFB_LIBS" + +AC_SUBST(DIRECTFB_SURFACE_FEATURE) + +dnl =========================================================================== + AC_ARG_ENABLE(xlib, [ --disable-xlib Disable cairo's Xlib backend], [use_xlib=$enableval], [use_xlib=yes]) @@ -435,6 +459,7 @@ echo " PDF: $use_pdf" echo " PNG: $use_png" echo " glitz: $use_glitz" +echo " directfb: $use_directfb" echo "" echo "and the following font backends:" echo " FreeType: $use_freetype" Index: src/Makefile.am =================================================================== RCS file: /cvs/cairo/cairo/src/Makefile.am,v retrieving revision 1.39 diff -u -w -r1.39 Makefile.am --- src/Makefile.am 4 Feb 2005 16:04:36 -0000 1.39 +++ src/Makefile.am 11 Feb 2005 18:06:18 -0000 @@ -43,6 +43,11 @@ libcairo_glitz_sources = cairo_glitz_surface.c endif +if CAIRO_HAS_DIRECTFB_SURFACE +libcairo_directfb_headers = cairo-directfb.h +libcairo_directfb_sources = cairo_directfb_surface.c +endif + if CAIRO_HAS_ATSUI_FONT libcairo_atsui_headers = cairo-atsui.h libcairo_atsui_sources = cairo_atsui_font.c @@ -66,6 +71,7 @@ cairo-features.h \ $(libcairo_atsui_headers) \ $(libcairo_ft_headers) \ + $(libcairo_directfb_headers) \ $(libcairo_glitz_headers) \ $(libcairo_pdf_headers) \ $(libcairo_png_headers) \ @@ -113,6 +119,7 @@ $(libcairo_xcb_sources) \ $(libcairo_glitz_sources)\ $(libcairo_win32_sources)\ + $(libcairo_directfb_sources)\ $(libcairo_freetype_sources) \ cairoint.h Index: src/cairo-directfb.h =================================================================== RCS file: src/cairo-directfb.h diff -N src/cairo-directfb.h --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ src/cairo-directfb.h 11 Feb 2005 18:06:18 -0000 @@ -0,0 +1,64 @@ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2003 University of Southern California + * + * This library is free software; you can redistribute it and/or + * modify it either under the terms of the GNU Lesser General Public + * License version 2.1 as published by the Free Software Foundation + * (the "LGPL") or, at your option, under the terms of the Mozilla + * Public License Version 1.1 (the "MPL"). If you do not alter this + * notice, a recipient may use your version of this file under either + * the MPL or the LGPL. + * + * You should have received a copy of the LGPL along with this library + * in the file COPYING-LGPL-2.1; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * You should have received a copy of the MPL along with this library + * in the file COPYING-MPL-1.1 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth + */ + +#ifndef CAIRO_DIRECTFB_H +#define CAIRO_DIRECTFB_H + +#include + +#ifdef CAIRO_HAS_DIRECTFB_SURFACE + +CAIRO_BEGIN_DECLS + +void +cairo_set_target_directfb( cairo_t *cr,IDirectFB *dfb,IDirectFBSurface *surface); + +cairo_surface_t * +cairo_directfb_surface_create (IDirectFB *dfb, IDirectFBSurface *surface); + +CAIRO_END_DECLS + + + +#endif /*CAIRO_HAS_DIRECTFB_SURFACE*/ +#endif /*CAIRO_DIRECTFB_H*/ + + + + + + + Index: src/cairo_directfb_surface.c =================================================================== RCS file: src/cairo_directfb_surface.c diff -N src/cairo_directfb_surface.c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ src/cairo_directfb_surface.c 11 Feb 2005 18:06:19 -0000 @@ -0,0 +1,520 @@ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2003 University of Southern California + * + * This library is free software; you can redistribute it and/or + * modify it either under the terms of the GNU Lesser General Public + * License version 2.1 as published by the Free Software Foundation + * (the "LGPL") or, at your option, under the terms of the Mozilla + * Public License Version 1.1 (the "MPL"). If you do not alter this + * notice, a recipient may use your version of this file under either + * the MPL or the LGPL. + * + * You should have received a copy of the LGPL along with this library + * in the file COPYING-LGPL-2.1; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * You should have received a copy of the MPL along with this library + * in the file COPYING-MPL-1.1 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth + */ +#include +#include +#include "cairoint.h" +#include "cairo-directfb.h" + + +#define TRACE printf(" IN %s %d \n",__FUNCTION__,__LINE__) + +/* macro for a safe call to DirectFB functions */ +#define DFBCHECK(x...) \ +{ \ + err = x; \ + if (err != DFB_OK) { \ + fprintf( stderr, "%s <%d>:\n\t", __FILE__, __LINE__ ); \ + DirectFBErrorFatal( #x, err ); \ + } \ +} + +cairo_surface_t * +cairo_directfb_surface_create ( IDirectFB *dfb,IDirectFBSurface *dsurface); +void +cairo_set_target_directfb( cairo_t *cr,IDirectFB *dfb, IDirectFBSurface *dsurface ); + + + +typedef struct cairo_directfb_surface { + cairo_surface_t base; + IDirectFB *dfb; + IDirectFBSurface * dsurface; + DFBRegion *rects; /*complex clip rects*/ + int repeat; +} cairo_directfb_surface_t; + +static cairo_format_t dfb_to_cairo_format( int dfb_format ) { + switch( dfb_format ) { + case DSPF_UNKNOWN : + case DSPF_ARGB1555 : + case DSPF_RGB16 : + case DSPF_RGB24 : + return -1; + case DSPF_RGB32 : + return CAIRO_FORMAT_RGB24; + case DSPF_ARGB : + return CAIRO_FORMAT_ARGB32; + case DSPF_A8 : + return CAIRO_FORMAT_A8; + case DSPF_YUY2 : + case DSPF_RGB332 : + case DSPF_UYVY : + case DSPF_I420 : + case DSPF_ALUT44 : + case DSPF_AiRGB : + return -1; + case DSPF_A1 : + return CAIRO_FORMAT_A1; + case DSPF_NV12 : + case DSPF_NV16 : + default : + return -1; + } + return -1; +} + +static cairo_status_t +lock_image( void *abstract_surface,cairo_rectangle_t *interest_rect, + cairo_image_surface_t **image_out,cairo_rectangle_t *image_rect, + void **image_extra, DFBSurfaceLockFlags flags) +{ + TRACE; + //XXX handle intrest rect + cairo_directfb_surface_t *csrc=abstract_surface; + IDirectFBSurface *src=csrc->dsurface; + cairo_status_t status = CAIRO_STATUS_SUCCESS; + DFBSurfacePixelFormat dfbformat; + void *data=NULL; + int pitch=0; + int width=0; + int height=0; + int x1, y1, x2, y2; + src->Lock(src,flags,&data,&pitch); + src->GetSize(src,&width,&height); + src->GetPixelFormat(src,&dfbformat); + cairo_format_t format = dfb_to_cairo_format(dfbformat); + x1 = 0; + y1 = 0; + x2 = width; + y2 = height; + if (interest_rect) { + if (interest_rect->x > x1) + x1 = interest_rect->x; + if (interest_rect->y > y1) + y1 = interest_rect->y; + if (interest_rect->x + interest_rect->width < x2) + x2 = interest_rect->x + interest_rect->width; + if (interest_rect->y + interest_rect->height < y2) + y2 = interest_rect->y + interest_rect->height; + + if (x1 >= x2 || y1 >= y2) { + *image_out = NULL; + return CAIRO_STATUS_SUCCESS; + } + } + + if (image_rect) { + image_rect->x = x1; + image_rect->y = y1; + image_rect->width = x2 - x1; + image_rect->height = y2 - y1; + } + char *cdata = (char *)data; + //XXX need bpp + cdata += x1*4 + y1*pitch; + *image_out=(cairo_image_surface_t *) + cairo_image_surface_create_for_data (cdata, + format, + width, + height, + pitch); + _cairo_image_surface_set_repeat (*image_out, csrc->base.repeat); + _cairo_image_surface_set_matrix (*image_out, &(csrc->base.matrix)); + return status; +} + + + +static cairo_surface_t * +_cairo_directfb_surface_create_similar( void *abstract_src, + cairo_format_t format, + int drawable, + int width, + int height) +{ + TRACE; + cairo_directfb_surface_t *csrc=abstract_src; + IDirectFBSurface *src=csrc->dsurface; + IDirectFBSurface * dsurface; + DFBSurfaceDescription desc; + DFBRectangle rect; + int err; + src->GetCapabilities(src,&desc.caps); + src->GetPixelFormat(src,&desc.pixelformat); + desc.flags = DSDESC_CAPS |DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT ; + desc.width=width; + desc.height=width; + rect.x=0; + rect.y=0; + rect.w=width; + rect.h=height; + + DFBCHECK(csrc->dfb->CreateSurface(csrc->dfb,&desc, &dsurface)); + dsurface->Blit(dsurface,src,&rect,0,0); + return cairo_directfb_surface_create(csrc->dfb,dsurface); +} + + + static void +_cairo_directfb_surface_destroy(void *abstract_surface) +{ + TRACE; + cairo_directfb_surface_t *surface = abstract_surface; + surface->dsurface->Release(surface->dsurface); + free(surface); +} + + + static double +_cairo_directfb_surface_pixels_per_inch(void *abstract_surface) +{ + TRACE; + + + // TODO - get this from CGDirectDisplay somehow? + return 96.0; +} + + +static cairo_status_t +_cairo_directfb_surface_acquire_source_image( void *abstract_surface, + cairo_image_surface_t **image_out, + void **image_extra) +{ + TRACE; + return lock_image(abstract_surface,NULL, + image_out,NULL,image_extra,DSLF_READ); +} + + +static void +_cairo_directfb_surface_release_source_image( void *abstract_surface, + cairo_image_surface_t *image, + void *image_extra) +{ + TRACE; + cairo_directfb_surface_t *surface = abstract_surface; + surface->dsurface->Unlock(surface->dsurface); + //cairo_surface_destroy (&image->base); +} + +static cairo_status_t +_cairo_directfb_surface_acquire_dest_image( void *abstract_surface, + cairo_rectangle_t *intrest_rect, + cairo_image_surface_t **image_out, + cairo_rectangle_t *image_rect, + void **image_extra) +{ + TRACE; + return lock_image(abstract_surface,intrest_rect,image_out,image_rect,image_extra, + DSLF_READ|DSLF_WRITE); +} + + +static void +_cairo_directfb_surface_release_dest_image( void *abstract_surface, + cairo_rectangle_t *intrest_rect, + cairo_image_surface_t *image, + cairo_rectangle_t *image_rect, + void *image_extra) +{ + TRACE; + cairo_directfb_surface_t *surface = abstract_surface; + surface->dsurface->Unlock(surface->dsurface); + //image_extra indicates that a subregion was locked + if( image_rect && image_extra ) { + int width; + int height; + surface->dsurface->GetSize(surface->dsurface,&width,&height); + DFBRegion region; + region.x1=image_rect->x; + region.y1=image_rect->y; + region.x2=image_rect->x+image_rect->width; + region.y2=image_rect->y+image_rect->height; + surface->dsurface->Flip(surface->dsurface,®ion,DSFLIP_BLIT); + }else { + surface->dsurface->Flip(surface->dsurface,NULL,0); + } + //cairo_surface_destroy (&image->base); +} + +static cairo_status_t +_cairo_directfb_surface_clone_similar( void *abstract_surface, + cairo_surface_t *src, + cairo_surface_t **clone_out ) +{ + TRACE; + cairo_status_t status = CAIRO_STATUS_SUCCESS; + return status; + + +} + +static cairo_status_t +_cairo_directfb_surface_set_matrix(void *abstract_surface, + cairo_matrix_t *matrix) +{ + TRACE; + //cairo_directfb_surface_t *surface = abstract_surface; + //return _cairo_image_surface_set_matrix(surface->image, matrix); + cairo_status_t status; + status = CAIRO_STATUS_SUCCESS; + return status; +} + + + static cairo_status_t +_cairo_directfb_surface_set_filter(void *abstract_surface, cairo_filter_t filter) +{ + TRACE; + cairo_directfb_surface_t *surface = abstract_surface; + (void)surface; + return CAIRO_INT_STATUS_UNSUPPORTED; +} + + + static cairo_status_t +_cairo_directfb_surface_set_repeat(void *abstract_surface, int repeat) +{ + TRACE; + cairo_directfb_surface_t *surface = abstract_surface; + surface->repeat=repeat; + return CAIRO_STATUS_SUCCESS; + +} + + +static cairo_int_status_t +_cairo_directfb_surface_composite( cairo_operator_t operator, + cairo_pattern_t *src, + cairo_surface_t *mask, + void *dst, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + unsigned int width, + unsigned int height) +{ + TRACE; + return CAIRO_INT_STATUS_UNSUPPORTED; +} + + +static cairo_int_status_t +_cairo_directfb_surface_fill_rectangles( void *abstract_surface, + cairo_operator_t operator, + const cairo_color_t *color, + cairo_rectangle_t *rects, + int num_rects) +{ + TRACE; + return CAIRO_INT_STATUS_UNSUPPORTED; +} + + +static cairo_int_status_t +_cairo_directfb_surface_composite_trapezoids( cairo_operator_t operator, + cairo_pattern_t *pattern, + void *abstract_dst, + int src_x, + int src_y, + int dst_x, + int dst_y, + unsigned int width, + unsigned int heigth, + cairo_trapezoid_t *traps, + int num_traps) +{ + TRACE; + return CAIRO_INT_STATUS_UNSUPPORTED; +} + + + static cairo_int_status_t +_cairo_directfb_surface_copy_page(void *abstract_surface) +{ + TRACE; + return CAIRO_INT_STATUS_UNSUPPORTED; +} + + + static cairo_int_status_t +_cairo_directfb_surface_show_page(void *abstract_surface) +{ + TRACE; + return CAIRO_INT_STATUS_UNSUPPORTED; +} + + +static cairo_int_status_t +_cairo_directfb_surface_set_clip_region( void *abstract_surface, + pixman_region16_t *region) +{ + TRACE; + cairo_directfb_surface_t *surface = abstract_surface; + pixman_box16_t *box; + if( surface->rects != NULL ) { + free(surface->rects); + surface->rects=NULL; + } + /*reset clip*/ + if( region == NULL ) { + surface->dsurface->SetClip(surface->dsurface,NULL); + return CAIRO_STATUS_SUCCESS; + } + + int n = pixman_region_num_rects (region); + /* XXX: Are we sure these are the semantics we want for an + * empty, (not null) region? */ + if (n == 0) + return CAIRO_STATUS_SUCCESS; + if( n == 1 ) { + box = pixman_region_rects (region); + DFBRegion dfbregion; + dfbregion.x1= box->x1; + dfbregion.y1= box->y1; + dfbregion.x2= box->x2; + dfbregion.y1= box->y2; + surface->dsurface->SetClip(surface->dsurface,&dfbregion); + return CAIRO_STATUS_SUCCESS; + }else { + surface->dsurface->SetClip(surface->dsurface,NULL); + DFBRegion *rects = malloc(sizeof(DFBRegion) * n); + if (rects == NULL) + return CAIRO_STATUS_NO_MEMORY; + box = pixman_region_rects (region); + + for (; n > 0; --n, ++box) { + rects[n-1].x1 = box->x1; + rects[n-1].y1 = box->y1; + rects[n-1].x2 = box->x2; + rects[n-1].y2 = box->y2; + } + surface->rects=rects; + } + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +_cairo_directfb_surface_show_glyphs (cairo_font_t *font, + cairo_operator_t operator, + cairo_pattern_t *pattern, + void *abstract_surface, + int source_x, + int source_y, + int dest_x, + int dest_y, + unsigned int width, + unsigned int height, + const cairo_glyph_t *glyphs, + int num_glyphs) +{ + TRACE; + return CAIRO_INT_STATUS_UNSUPPORTED; +} + + + +static const struct _cairo_surface_backend cairo_directfb_surface_backend = { + _cairo_directfb_surface_create_similar, + _cairo_directfb_surface_destroy, + _cairo_directfb_surface_pixels_per_inch, + _cairo_directfb_surface_acquire_source_image, + _cairo_directfb_surface_release_source_image, + _cairo_directfb_surface_acquire_dest_image, + _cairo_directfb_surface_release_dest_image, + _cairo_directfb_surface_clone_similar, + _cairo_directfb_surface_set_matrix, + _cairo_directfb_surface_set_filter, + _cairo_directfb_surface_set_repeat, + _cairo_directfb_surface_composite, + _cairo_directfb_surface_fill_rectangles, + _cairo_directfb_surface_composite_trapezoids, + _cairo_directfb_surface_copy_page, + _cairo_directfb_surface_show_page, + _cairo_directfb_surface_set_clip_region, + _cairo_directfb_surface_show_glyphs +}; + + + +cairo_surface_t * +cairo_directfb_surface_create ( IDirectFB *dfb,IDirectFBSurface *dsurface) +{ + TRACE; + cairo_directfb_surface_t *surface; + surface = malloc(sizeof(cairo_directfb_surface_t)); + if (surface == NULL) + return NULL; + + _cairo_surface_init(&surface->base, &cairo_directfb_surface_backend); + + + surface->dfb=dfb; + surface->dsurface = dsurface; + return (cairo_surface_t *)surface; +} + + + + void +cairo_set_target_directfb( cairo_t *cr,IDirectFB *dfb, IDirectFBSurface *dsurface ) +{ + TRACE; + cairo_surface_t *surface; + + if (cr->status && cr->status != CAIRO_STATUS_NO_TARGET_SURFACE) + return; + surface = cairo_directfb_surface_create(dfb,dsurface); + + if (surface == NULL) + { + cr->status = CAIRO_STATUS_NO_MEMORY; + return; + } + cairo_set_target_surface(cr, surface); + /* cairo_set_target_surface takes a reference, so we must destroy ours */ + cairo_surface_destroy(surface); +} + + + + + + Index: src/cairoint.h =================================================================== RCS file: /cvs/cairo/cairo/src/cairoint.h,v retrieving revision 1.94 diff -u -w -r1.94 cairoint.h --- src/cairoint.h 1 Feb 2005 23:06:36 -0000 1.94 +++ src/cairoint.h 11 Feb 2005 18:06:21 -0000 @@ -1470,7 +1470,7 @@ _cairo_surface_pixels_per_inch (cairo_surface_t *surface); cairo_private cairo_status_t -_cairo_surface_acquire_source_image (cairo_surface_t *urface, +_cairo_surface_acquire_source_image (cairo_surface_t *surface, cairo_image_surface_t **image_out, void **image_extra);