new beta-0.90.0

[luatex.git] / source / libs / cairo / cairo-src / src / cairo-ps-surface.c

/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */
/* cairo - a vector graphics library with display and print output
 *
 * Copyright © 2003 University of Southern California
 * Copyright © 2005 Red Hat, Inc
 * Copyright © 2007,2008 Adrian Johnson
 *
 * 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., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, 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 <cworth@cworth.org>
 *      Kristian Høgsberg <krh@redhat.com>
 *      Keith Packard <keithp@keithp.com>
 *      Adrian Johnson <ajohnson@redneon.com>
 */


/*
 * Design of the PS output:
 *
 * The PS output is harmonised with the PDF operations using PS procedures
 * to emulate the PDF operators.
 *
 * This has a number of advantages:
 *   1. A large chunk of code is shared between the PDF and PS backends.
 *      See cairo-pdf-operators.
 *   2. Using gs to do PS -> PDF and PDF -> PS will always work well.
 */

#define _BSD_SOURCE /* for ctime_r(), snprintf(), strdup() */
#include "cairoint.h"

#include "cairo-ps.h"
#include "cairo-ps-surface-private.h"

#include "cairo-pdf-operators-private.h"
#include "cairo-pdf-shading-private.h"

#include "cairo-array-private.h"
#include "cairo-composite-rectangles-private.h"
#include "cairo-default-context-private.h"
#include "cairo-error-private.h"
#include "cairo-image-surface-inline.h"
#include "cairo-list-inline.h"
#include "cairo-scaled-font-subsets-private.h"
#include "cairo-paginated-private.h"
#include "cairo-recording-surface-private.h"
#include "cairo-surface-clipper-private.h"
#include "cairo-surface-snapshot-inline.h"
#include "cairo-surface-subsurface-private.h"
#include "cairo-output-stream-private.h"
#include "cairo-type3-glyph-surface-private.h"
#include "cairo-image-info-private.h"

#include <stdio.h>
#include <ctype.h>
#include <time.h>
#include <zlib.h>
#include <errno.h>

#define DEBUG_PS 0

#if DEBUG_PS
#define DEBUG_FALLBACK(s) \
    fprintf (stderr, "%s::%d -- %s\n", __FUNCTION__, __LINE__, (s))
#else
#define DEBUG_FALLBACK(s)
#endif

#ifndef HAVE_CTIME_R
#define ctime_r(T, BUF) ctime (T)
#endif

/**
 * SECTION:cairo-ps
 * @Title: PostScript Surfaces
 * @Short_Description: Rendering PostScript documents
 * @See_Also: #cairo_surface_t
 *
 * The PostScript surface is used to render cairo graphics to Adobe
 * PostScript files and is a multi-page vector surface backend.
 **/

/**
 * CAIRO_HAS_PS_SURFACE:
 * 
 * Defined if the PostScript surface backend is available.
 * This macro can be used to conditionally compile backend-specific code.
 *
 * Since: 1.2
 **/

typedef enum {
    CAIRO_PS_COMPRESS_NONE,
    CAIRO_PS_COMPRESS_LZW,
    CAIRO_PS_COMPRESS_DEFLATE
 } cairo_ps_compress_t;

static const cairo_surface_backend_t cairo_ps_surface_backend;
static const cairo_paginated_surface_backend_t cairo_ps_surface_paginated_backend;

static cairo_bool_t
_cairo_ps_surface_get_extents (void                    *abstract_surface,
                               cairo_rectangle_int_t   *rectangle);

static const cairo_ps_level_t _cairo_ps_levels[] =
{
    CAIRO_PS_LEVEL_2,
    CAIRO_PS_LEVEL_3
};

#define CAIRO_PS_LEVEL_LAST ARRAY_LENGTH (_cairo_ps_levels)

static const char * _cairo_ps_level_strings[CAIRO_PS_LEVEL_LAST] =
{
    "PS Level 2",
    "PS Level 3"
};

static const char *_cairo_ps_supported_mime_types[] =
{
    CAIRO_MIME_TYPE_JPEG,
    NULL
};

typedef struct _cairo_page_standard_media {
    const char *name;
    int width;
    int height;
} cairo_page_standard_media_t;

static const cairo_page_standard_media_t _cairo_page_standard_media[] =
{
    { "A0",       2384, 3371 },
    { "A1",       1685, 2384 },
    { "A2",       1190, 1684 },
    { "A3",        842, 1190 },
    { "A4",        595,  842 },
    { "A5",        420,  595 },
    { "B4",        729, 1032 },
    { "B5",        516,  729 },
    { "Letter",    612,  792 },
    { "Tabloid",   792, 1224 },
    { "Ledger",   1224,  792 },
    { "Legal",     612, 1008 },
    { "Statement", 396,  612 },
    { "Executive", 540,  720 },
    { "Folio",     612,  936 },
    { "Quarto",    610,  780 },
    { "10x14",     720, 1008 },
};

typedef struct _cairo_page_media {
    char *name;
    int width;
    int height;
    cairo_list_t link;
} cairo_page_media_t;

static void
_cairo_ps_surface_emit_header (cairo_ps_surface_t *surface)
{
    char ctime_buf[26];
    time_t now;
    char **comments;
    int i, num_comments;
    int level;
    const char *eps_header = "";
    cairo_bool_t has_bbox;

    if (surface->has_creation_date)
        now = surface->creation_date;
    else
        now = time (NULL);

    if (surface->ps_level_used == CAIRO_PS_LEVEL_2)
        level = 2;
    else
        level = 3;

    if (surface->eps)
        eps_header = " EPSF-3.0";

    _cairo_output_stream_printf (surface->final_stream,
                                 "%%!PS-Adobe-3.0%s\n"
                                 "%%%%Creator: cairo %s (http://cairographics.org)\n"
                                 "%%%%CreationDate: %s"
                                 "%%%%Pages: %d\n",
                                 eps_header,
                                 cairo_version_string (),
                                 ctime_r (&now, ctime_buf),
                                 surface->num_pages);

    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%DocumentData: Clean7Bit\n"
                                 "%%%%LanguageLevel: %d\n",
                                 level);

    if (!cairo_list_is_empty (&surface->document_media)) {
        cairo_page_media_t *page;
        cairo_bool_t first = TRUE;

        cairo_list_foreach_entry (page, cairo_page_media_t, &surface->document_media, link) {
            if (first) {
                _cairo_output_stream_printf (surface->final_stream,
                                             "%%%%DocumentMedia: ");
                first = FALSE;
            } else {
                _cairo_output_stream_printf (surface->final_stream,
                                             "%%%%+ ");
            }
            _cairo_output_stream_printf (surface->final_stream,
                                         "%s %d %d 0 () ()\n",
                                         page->name,
                                         page->width,
                                         page->height);
        }
    }

    has_bbox = FALSE;
    num_comments = _cairo_array_num_elements (&surface->dsc_header_comments);
    comments = _cairo_array_index (&surface->dsc_header_comments, 0);
    for (i = 0; i < num_comments; i++) {
        _cairo_output_stream_printf (surface->final_stream,
                                     "%s\n", comments[i]);
        if (strncmp (comments[i], "%%BoundingBox:", 14) == 0)
            has_bbox = TRUE;

        free (comments[i]);
        comments[i] = NULL;
    }

    if (!has_bbox) {
        _cairo_output_stream_printf (surface->final_stream,
                                     "%%%%BoundingBox: %d %d %d %d\n",
                                     surface->bbox_x1,
                                     surface->bbox_y1,
                                     surface->bbox_x2,
                                     surface->bbox_y2);
    }

    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%EndComments\n");

    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%BeginProlog\n");

    if (surface->eps) {
        _cairo_output_stream_printf (surface->final_stream,
                                     "save\n"
                                     "50 dict begin\n");
    } else {
        _cairo_output_stream_printf (surface->final_stream,
                                     "/languagelevel where\n"
                                     "{ pop languagelevel } { 1 } ifelse\n"
                                     "%d lt { /Helvetica findfont 12 scalefont setfont 50 500 moveto\n"
                                     "  (This print job requires a PostScript Language Level %d printer.) show\n"
                                     "  showpage quit } if\n",
                                     level,
                                     level);
    }

    _cairo_output_stream_printf (surface->final_stream,
                                 "/q { gsave } bind def\n"
                                 "/Q { grestore } bind def\n"
                                 "/cm { 6 array astore concat } bind def\n"
                                 "/w { setlinewidth } bind def\n"
                                 "/J { setlinecap } bind def\n"
                                 "/j { setlinejoin } bind def\n"
                                 "/M { setmiterlimit } bind def\n"
                                 "/d { setdash } bind def\n"
                                 "/m { moveto } bind def\n"
                                 "/l { lineto } bind def\n"
                                 "/c { curveto } bind def\n"
                                 "/h { closepath } bind def\n"
                                 "/re { exch dup neg 3 1 roll 5 3 roll moveto 0 rlineto\n"
                                 "      0 exch rlineto 0 rlineto closepath } bind def\n"
                                 "/S { stroke } bind def\n"
                                 "/f { fill } bind def\n"
                                 "/f* { eofill } bind def\n"
                                 "/n { newpath } bind def\n"
                                 "/W { clip } bind def\n"
                                 "/W* { eoclip } bind def\n"
                                 "/BT { } bind def\n"
                                 "/ET { } bind def\n"
                                 "/pdfmark where { pop globaldict /?pdfmark /exec load put }\n"
                                 "    { globaldict begin /?pdfmark /pop load def /pdfmark\n"
                                 "    /cleartomark load def end } ifelse\n"
                                 "/BDC { mark 3 1 roll /BDC pdfmark } bind def\n"
                                 "/EMC { mark /EMC pdfmark } bind def\n"
                                 "/cairo_store_point { /cairo_point_y exch def /cairo_point_x exch def } def\n"
                                 "/Tj { show currentpoint cairo_store_point } bind def\n"
                                 "/TJ {\n"
                                 "  {\n"
                                 "    dup\n"
                                 "    type /stringtype eq\n"
                                 "    { show } { -0.001 mul 0 cairo_font_matrix dtransform rmoveto } ifelse\n"
                                 "  } forall\n"
                                 "  currentpoint cairo_store_point\n"
                                 "} bind def\n"
                                 "/cairo_selectfont { cairo_font_matrix aload pop pop pop 0 0 6 array astore\n"
                                 "    cairo_font exch selectfont cairo_point_x cairo_point_y moveto } bind def\n"
                                 "/Tf { pop /cairo_font exch def /cairo_font_matrix where\n"
                                 "      { pop cairo_selectfont } if } bind def\n"
                                 "/Td { matrix translate cairo_font_matrix matrix concatmatrix dup\n"
                                 "      /cairo_font_matrix exch def dup 4 get exch 5 get cairo_store_point\n"
                                 "      /cairo_font where { pop cairo_selectfont } if } bind def\n"
                                 "/Tm { 2 copy 8 2 roll 6 array astore /cairo_font_matrix exch def\n"
                                 "      cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def\n"
                                 "/g { setgray } bind def\n"
                                 "/rg { setrgbcolor } bind def\n"
                                 "/d1 { setcachedevice } bind def\n");

    if (!surface->eps) {
        _cairo_output_stream_printf (surface->final_stream,
                                     "/cairo_set_page_size {\n"
                                     "  %% Change paper size, but only if different from previous paper size otherwise\n"
                                     "  %% duplex fails. PLRM specifies a tolerance of 5 pts when matching paper size\n"
                                     "  %% so we use the same when checking if the size changes.\n"
                                     "  /setpagedevice where {\n"
                                     "    pop currentpagedevice\n"
                                     "    /PageSize known {\n"
                                     "      2 copy\n"
                                     "      currentpagedevice /PageSize get aload pop\n"
                                     "      exch 4 1 roll\n"
                                     "      sub abs 5 gt\n"
                                     "      3 1 roll\n"
                                     "      sub abs 5 gt\n"
                                     "      or\n"
                                     "    } {\n"
                                     "      true\n"
                                     "    } ifelse\n"
                                     "    {\n"
                                     "      2 array astore\n"
                                     "      2 dict begin\n"
                                     "        /PageSize exch def\n"
                                     "        /ImagingBBox null def\n"
                                     "      currentdict end\n"
                                     "      setpagedevice\n"
                                     "    } {\n"
                                     "      pop pop\n"
                                     "    } ifelse\n"
                                     "  } {\n"
                                     "    pop\n"
                                     "  } ifelse\n"
                                     "} def\n");
    }

    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%EndProlog\n");
    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%BeginSetup\n");

    num_comments = _cairo_array_num_elements (&surface->dsc_setup_comments);
    if (num_comments) {
        comments = _cairo_array_index (&surface->dsc_setup_comments, 0);
        for (i = 0; i < num_comments; i++) {
            _cairo_output_stream_printf (surface->final_stream,
                                         "%s\n", comments[i]);
            free (comments[i]);
            comments[i] = NULL;
        }
    }
}

static cairo_status_t
_cairo_ps_surface_emit_type1_font_subset (cairo_ps_surface_t            *surface,
                                          cairo_scaled_font_subset_t    *font_subset)


{
    cairo_type1_subset_t subset;
    cairo_status_t status;
    int length;
    char name[64];

    snprintf (name, sizeof name, "f-%d-%d",
              font_subset->font_id, font_subset->subset_id);
    status = _cairo_type1_subset_init (&subset, name, font_subset, TRUE);
    if (unlikely (status))
        return status;

    /* FIXME: Figure out document structure convention for fonts */

#if DEBUG_PS
    _cairo_output_stream_printf (surface->final_stream,
                                 "%% _cairo_ps_surface_emit_type1_font_subset\n");
#endif

    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%BeginResource: font %s\n",
                                 subset.base_font);
    length = subset.header_length + subset.data_length + subset.trailer_length;
    _cairo_output_stream_write (surface->final_stream, subset.data, length);
    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%EndResource\n");

    _cairo_type1_subset_fini (&subset);

    return CAIRO_STATUS_SUCCESS;
}


static cairo_status_t
_cairo_ps_surface_emit_type1_font_fallback (cairo_ps_surface_t          *surface,
                                            cairo_scaled_font_subset_t  *font_subset)
{
    cairo_type1_subset_t subset;
    cairo_status_t status;
    int length;
    char name[64];

    snprintf (name, sizeof name, "f-%d-%d",
              font_subset->font_id, font_subset->subset_id);
    status = _cairo_type1_fallback_init_hex (&subset, name, font_subset);
    if (unlikely (status))
        return status;

#if DEBUG_PS
    _cairo_output_stream_printf (surface->final_stream,
                                 "%% _cairo_ps_surface_emit_type1_font_fallback\n");
#endif

    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%BeginResource: font %s\n",
                                 subset.base_font);
    length = subset.header_length + subset.data_length + subset.trailer_length;
    _cairo_output_stream_write (surface->final_stream, subset.data, length);
    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%EndResource\n");

    _cairo_type1_fallback_fini (&subset);

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_ps_surface_emit_truetype_font_subset (cairo_ps_surface_t         *surface,
                                             cairo_scaled_font_subset_t *font_subset)


{
    cairo_truetype_subset_t subset;
    cairo_status_t status;
    unsigned int i, begin, end;

    status = _cairo_truetype_subset_init_ps (&subset, font_subset);
    if (unlikely (status))
        return status;

    /* FIXME: Figure out document structure convention for fonts */

#if DEBUG_PS
    _cairo_output_stream_printf (surface->final_stream,
                                 "%% _cairo_ps_surface_emit_truetype_font_subset\n");
#endif

    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%BeginResource: font %s\n",
                                 subset.ps_name);
    _cairo_output_stream_printf (surface->final_stream,
                                 "11 dict begin\n"
                                 "/FontType 42 def\n"
                                 "/FontName /%s def\n"
                                 "/PaintType 0 def\n"
                                 "/FontMatrix [ 1 0 0 1 0 0 ] def\n"
                                 "/FontBBox [ 0 0 0 0 ] def\n"
                                 "/Encoding 256 array def\n"
                                 "0 1 255 { Encoding exch /.notdef put } for\n",
                                 subset.ps_name);

    /* FIXME: Figure out how subset->x_max etc maps to the /FontBBox */

    if (font_subset->is_latin) {
        for (i = 1; i < 256; i++) {
            if (font_subset->latin_to_subset_glyph_index[i] > 0) {
                if (font_subset->glyph_names != NULL) {
                    _cairo_output_stream_printf (surface->final_stream,
                                                 "Encoding %d /%s put\n",
                                                 i, font_subset->glyph_names[font_subset->latin_to_subset_glyph_index[i]]);
                } else {
                    _cairo_output_stream_printf (surface->final_stream,
                                                 "Encoding %d /g%ld put\n", i, font_subset->latin_to_subset_glyph_index[i]);
                }
            }
        }
    } else {
        for (i = 1; i < font_subset->num_glyphs; i++) {
            if (font_subset->glyph_names != NULL) {
                _cairo_output_stream_printf (surface->final_stream,
                                             "Encoding %d /%s put\n",
                                             i, font_subset->glyph_names[i]);
            } else {
                _cairo_output_stream_printf (surface->final_stream,
                                             "Encoding %d /g%d put\n", i, i);
            }
        }
    }

    _cairo_output_stream_printf (surface->final_stream,
                                 "/CharStrings %d dict dup begin\n"
                                 "/.notdef 0 def\n",
                                 font_subset->num_glyphs);

    for (i = 1; i < font_subset->num_glyphs; i++) {
        if (font_subset->glyph_names != NULL) {
            _cairo_output_stream_printf (surface->final_stream,
                                         "/%s %d def\n",
                                         font_subset->glyph_names[i], i);
        } else {
            _cairo_output_stream_printf (surface->final_stream,
                                         "/g%d %d def\n", i, i);
        }
    }

    _cairo_output_stream_printf (surface->final_stream,
                                 "end readonly def\n");

    _cairo_output_stream_printf (surface->final_stream,
                                 "/sfnts [\n");
    begin = 0;
    end = 0;
    for (i = 0; i < subset.num_string_offsets; i++) {
        end = subset.string_offsets[i];
        _cairo_output_stream_printf (surface->final_stream,"<");
        _cairo_output_stream_write_hex_string (surface->final_stream,
                                               subset.data + begin, end - begin);
        _cairo_output_stream_printf (surface->final_stream,"00>\n");
        begin = end;
    }
    if (subset.data_length > end) {
        _cairo_output_stream_printf (surface->final_stream,"<");
        _cairo_output_stream_write_hex_string (surface->final_stream,
                                               subset.data + end, subset.data_length - end);
        _cairo_output_stream_printf (surface->final_stream,"00>\n");
    }

    _cairo_output_stream_printf (surface->final_stream,
                                 "] def\n"
                                 "/f-%d-%d currentdict end definefont pop\n",
                                 font_subset->font_id,
                                 font_subset->subset_id);
    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%EndResource\n");
    _cairo_truetype_subset_fini (&subset);


    return CAIRO_STATUS_SUCCESS;
}

static cairo_int_status_t
_cairo_ps_emit_imagemask (cairo_image_surface_t *image,
                          cairo_output_stream_t *stream)
{
    uint8_t *row, *byte;
    int rows, cols;

    /* The only image type supported by Type 3 fonts are 1-bit image
     * masks */
    assert (image->format == CAIRO_FORMAT_A1);

    _cairo_output_stream_printf (stream,
                                 "<<\n"
                                 "   /ImageType 1\n"
                                 "   /Width %d\n"
                                 "   /Height %d\n"
                                 "   /ImageMatrix [%d 0 0 %d 0 %d]\n"
                                 "   /Decode [1 0]\n"
                                 "   /BitsPerComponent 1\n",
                                 image->width,
                                 image->height,
                                 image->width,
                                 -image->height,
                                 image->height);

    _cairo_output_stream_printf (stream,
                                 "   /DataSource {<\n   ");
    for (row = image->data, rows = image->height; rows; row += image->stride, rows--) {
        for (byte = row, cols = (image->width + 7) / 8; cols; byte++, cols--) {
            uint8_t output_byte = CAIRO_BITSWAP8_IF_LITTLE_ENDIAN (*byte);
            _cairo_output_stream_printf (stream, "%02x ", output_byte);
        }
        _cairo_output_stream_printf (stream, "\n   ");
    }
    _cairo_output_stream_printf (stream, ">}\n>>\n");

    _cairo_output_stream_printf (stream,
                                 "imagemask\n");

    return _cairo_output_stream_get_status (stream);
}

static cairo_int_status_t
_cairo_ps_surface_analyze_user_font_subset (cairo_scaled_font_subset_t *font_subset,
                                            void                       *closure)
{
    cairo_ps_surface_t *surface = closure;
    cairo_status_t status = CAIRO_STATUS_SUCCESS;
    unsigned int i;
    cairo_surface_t *type3_surface;

    type3_surface = _cairo_type3_glyph_surface_create (font_subset->scaled_font,
                                                       NULL,
                                                       _cairo_ps_emit_imagemask,
                                                       surface->font_subsets,
                                                       TRUE);

    for (i = 0; i < font_subset->num_glyphs; i++) {
        status = _cairo_type3_glyph_surface_analyze_glyph (type3_surface,
                                                           font_subset->glyphs[i]);
        if (unlikely (status))
            break;

    }
    cairo_surface_finish (type3_surface);
    cairo_surface_destroy (type3_surface);

    return status;
}

static cairo_status_t
_cairo_ps_surface_emit_type3_font_subset (cairo_ps_surface_t            *surface,
                                          cairo_scaled_font_subset_t    *font_subset)


{
    cairo_status_t status;
    unsigned int i;
    cairo_box_t font_bbox = {{0,0},{0,0}};
    cairo_box_t bbox = {{0,0},{0,0}};
    cairo_surface_t *type3_surface;
    double width;

    if (font_subset->num_glyphs == 0)
        return CAIRO_STATUS_SUCCESS;

#if DEBUG_PS
    _cairo_output_stream_printf (surface->final_stream,
                                 "%% _cairo_ps_surface_emit_type3_font_subset\n");
#endif

    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%BeginResource: font\n");
    _cairo_output_stream_printf (surface->final_stream,
                                 "8 dict begin\n"
                                 "/FontType 3 def\n"
                                 "/FontMatrix [1 0 0 1 0 0] def\n"
                                 "/Encoding 256 array def\n"
                                 "0 1 255 { Encoding exch /.notdef put } for\n");

    type3_surface = _cairo_type3_glyph_surface_create (font_subset->scaled_font,
                                                       NULL,
                                                       _cairo_ps_emit_imagemask,
                                                       surface->font_subsets,
                                                       TRUE);
    status = type3_surface->status;
    if (unlikely (status))
        return status;

    for (i = 0; i < font_subset->num_glyphs; i++) {
        if (font_subset->glyph_names != NULL) {
            _cairo_output_stream_printf (surface->final_stream,
                                         "Encoding %d /%s put\n",
                                         i, font_subset->glyph_names[i]);
        } else {
            _cairo_output_stream_printf (surface->final_stream,
                                         "Encoding %d /g%d put\n", i, i);
        }
    }

    _cairo_output_stream_printf (surface->final_stream,
                                 "/Glyphs [\n");

    for (i = 0; i < font_subset->num_glyphs; i++) {
        _cairo_output_stream_printf (surface->final_stream,
                                     "    { %% %d\n", i);
        status = _cairo_type3_glyph_surface_emit_glyph (type3_surface,
                                                        surface->final_stream,
                                                        font_subset->glyphs[i],
                                                        &bbox,
                                                        &width);
        if (unlikely (status))
            break;

        _cairo_output_stream_printf (surface->final_stream,
                                     "    }\n");
        if (i == 0) {
            font_bbox.p1.x = bbox.p1.x;
            font_bbox.p1.y = bbox.p1.y;
            font_bbox.p2.x = bbox.p2.x;
            font_bbox.p2.y = bbox.p2.y;
        } else {
            if (bbox.p1.x < font_bbox.p1.x)
                font_bbox.p1.x = bbox.p1.x;
            if (bbox.p1.y < font_bbox.p1.y)
                font_bbox.p1.y = bbox.p1.y;
            if (bbox.p2.x > font_bbox.p2.x)
                font_bbox.p2.x = bbox.p2.x;
            if (bbox.p2.y > font_bbox.p2.y)
                font_bbox.p2.y = bbox.p2.y;
        }
    }
    cairo_surface_finish (type3_surface);
    cairo_surface_destroy (type3_surface);
    if (unlikely (status))
        return status;

    _cairo_output_stream_printf (surface->final_stream,
                                 "] def\n"
                                 "/FontBBox [%f %f %f %f] def\n"
                                 "/BuildChar {\n"
                                 "  exch /Glyphs get\n"
                                 "  exch get\n"
                                 "  10 dict begin exec end\n"
                                 "} bind def\n"
                                 "currentdict\n"
                                 "end\n"
                                 "/f-%d-%d exch definefont pop\n",
                                 _cairo_fixed_to_double (font_bbox.p1.x),
                                 - _cairo_fixed_to_double (font_bbox.p2.y),
                                 _cairo_fixed_to_double (font_bbox.p2.x),
                                 - _cairo_fixed_to_double (font_bbox.p1.y),
                                 font_subset->font_id,
                                 font_subset->subset_id);
    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%EndResource\n");

    return CAIRO_STATUS_SUCCESS;
}

static cairo_int_status_t
_cairo_ps_surface_emit_unscaled_font_subset (cairo_scaled_font_subset_t *font_subset,
                                            void                        *closure)
{
    cairo_ps_surface_t *surface = closure;
    cairo_int_status_t status;

    status = _cairo_scaled_font_subset_create_glyph_names (font_subset);
    if (_cairo_int_status_is_error (status))
        return status;

    status = _cairo_ps_surface_emit_type1_font_subset (surface, font_subset);
    if (status != CAIRO_INT_STATUS_UNSUPPORTED)
        return status;

    status = _cairo_ps_surface_emit_truetype_font_subset (surface, font_subset);
    if (status != CAIRO_INT_STATUS_UNSUPPORTED)
        return status;

    status = _cairo_ps_surface_emit_type1_font_fallback (surface, font_subset);
    if (status != CAIRO_INT_STATUS_UNSUPPORTED)
        return status;

    ASSERT_NOT_REACHED;
    return CAIRO_STATUS_SUCCESS;
}

static cairo_int_status_t
_cairo_ps_surface_emit_scaled_font_subset (cairo_scaled_font_subset_t *font_subset,
                                           void                       *closure)
{
    cairo_ps_surface_t *surface = closure;
    cairo_int_status_t status;

    status = _cairo_scaled_font_subset_create_glyph_names (font_subset);
    if (_cairo_int_status_is_error (status))
        return status;

    status = _cairo_ps_surface_emit_type3_font_subset (surface, font_subset);
    if (status != CAIRO_INT_STATUS_UNSUPPORTED)
        return status;

    ASSERT_NOT_REACHED;
    return CAIRO_INT_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_ps_surface_emit_font_subsets (cairo_ps_surface_t *surface)
{
    cairo_status_t status;

#if DEBUG_PS
    _cairo_output_stream_printf (surface->final_stream,
                                 "%% _cairo_ps_surface_emit_font_subsets\n");
#endif

    status = _cairo_scaled_font_subsets_foreach_user (surface->font_subsets,
                                                      _cairo_ps_surface_analyze_user_font_subset,
                                                      surface);
    if (unlikely (status))
        return status;

    status = _cairo_scaled_font_subsets_foreach_unscaled (surface->font_subsets,
                                                          _cairo_ps_surface_emit_unscaled_font_subset,
                                                          surface);
    if (unlikely (status))
        return status;

    status = _cairo_scaled_font_subsets_foreach_scaled (surface->font_subsets,
                                                        _cairo_ps_surface_emit_scaled_font_subset,
                                                        surface);
    if (unlikely (status))
        return status;

    return _cairo_scaled_font_subsets_foreach_user (surface->font_subsets,
                                                    _cairo_ps_surface_emit_scaled_font_subset,
                                                    surface);
}

static cairo_status_t
_cairo_ps_surface_emit_body (cairo_ps_surface_t *surface)
{
    char    buf[4096];
    int     n;

    if (ferror (surface->tmpfile) != 0)
        return _cairo_error (CAIRO_STATUS_TEMP_FILE_ERROR);

    rewind (surface->tmpfile);
    while ((n = fread (buf, 1, sizeof (buf), surface->tmpfile)) > 0)
        _cairo_output_stream_write (surface->final_stream, buf, n);

    if (ferror (surface->tmpfile) != 0)
        return _cairo_error (CAIRO_STATUS_TEMP_FILE_ERROR);

    return CAIRO_STATUS_SUCCESS;
}

static void
_cairo_ps_surface_emit_footer (cairo_ps_surface_t *surface)
{
    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%Trailer\n");

    if (surface->eps) {
        _cairo_output_stream_printf (surface->final_stream,
                                     "end restore\n");
    }

    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%EOF\n");
}

static cairo_bool_t
_path_covers_bbox (cairo_ps_surface_t *surface,
                   cairo_path_fixed_t *path)
{
    cairo_box_t box;

    if (_cairo_path_fixed_is_box (path, &box)) {
        cairo_rectangle_int_t rect;

        _cairo_box_round_to_rectangle (&box, &rect);

        /* skip trivial whole-page clips */
        if (_cairo_rectangle_intersect (&rect, &surface->page_bbox)) {
            if (rect.x == surface->page_bbox.x &&
                rect.width == surface->page_bbox.width &&
                rect.y == surface->page_bbox.y &&
                rect.height == surface->page_bbox.height)
            {
                return TRUE;
            }
        }
    }

    return FALSE;
}

static cairo_status_t
_cairo_ps_surface_clipper_intersect_clip_path (cairo_surface_clipper_t *clipper,
                                               cairo_path_fixed_t *path,
                                               cairo_fill_rule_t   fill_rule,
                                               double               tolerance,
                                               cairo_antialias_t   antialias)
{
    cairo_ps_surface_t *surface = cairo_container_of (clipper,
                                                      cairo_ps_surface_t,
                                                      clipper);
    cairo_output_stream_t *stream = surface->stream;
    cairo_status_t status;

    assert (surface->paginated_mode != CAIRO_PAGINATED_MODE_ANALYZE);

#if DEBUG_PS
    _cairo_output_stream_printf (stream,
                                 "%% _cairo_ps_surface_intersect_clip_path\n");
#endif

    if (path == NULL) {
        status = _cairo_pdf_operators_flush (&surface->pdf_operators);
        if (unlikely (status))
            return status;

        _cairo_output_stream_printf (stream, "Q q\n");

        surface->current_pattern_is_solid_color = FALSE;
        _cairo_pdf_operators_reset (&surface->pdf_operators);

        return CAIRO_STATUS_SUCCESS;
    }

    if (_path_covers_bbox (surface, path))
        return CAIRO_STATUS_SUCCESS;

    return _cairo_pdf_operators_clip (&surface->pdf_operators,
                                      path,
                                      fill_rule);
}

/* PLRM specifies a tolerance of 5 points when matching page sizes */
static cairo_bool_t
_ps_page_dimension_equal (int a, int b)
{
    return (abs (a - b) < 5);
}

static const char *
_cairo_ps_surface_get_page_media (cairo_ps_surface_t     *surface)
{
    int width, height, i;
    char buf[50];
    cairo_page_media_t *page;
    const char *page_name;

    width = _cairo_lround (surface->width);
    height = _cairo_lround (surface->height);

    /* search previously used page sizes */
    cairo_list_foreach_entry (page, cairo_page_media_t, &surface->document_media, link) {
        if (_ps_page_dimension_equal (width, page->width) &&
            _ps_page_dimension_equal (height, page->height))
            return page->name;
    }

    /* search list of standard page sizes */
    page_name = NULL;
    for (i = 0; i < ARRAY_LENGTH (_cairo_page_standard_media); i++) {
        if (_ps_page_dimension_equal (width, _cairo_page_standard_media[i].width) &&
            _ps_page_dimension_equal (height, _cairo_page_standard_media[i].height))
        {
            page_name = _cairo_page_standard_media[i].name;
            width = _cairo_page_standard_media[i].width;
            height = _cairo_page_standard_media[i].height;
            break;
        }
    }

    page = malloc (sizeof (cairo_page_media_t));
    if (unlikely (page == NULL)) {
        _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
        return NULL;
    }

    if (page_name) {
        page->name = strdup (page_name);
    } else {
        snprintf (buf, sizeof (buf), "%dx%dmm",
                  (int) _cairo_lround (surface->width * 25.4/72),
                  (int) _cairo_lround (surface->height * 25.4/72));
        page->name = strdup (buf);
    }

    if (unlikely (page->name == NULL)) {
        free (page);
        _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
        return NULL;
    }

    page->width = width;
    page->height = height;
    cairo_list_add_tail (&page->link, &surface->document_media);

    return page->name;
}

static cairo_surface_t *
_cairo_ps_surface_create_for_stream_internal (cairo_output_stream_t *stream,
                                              double                 width,
                                              double                 height)
{
    cairo_status_t status, status_ignored;
    cairo_ps_surface_t *surface;

    surface = malloc (sizeof (cairo_ps_surface_t));
    if (unlikely (surface == NULL)) {
        status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
        goto CLEANUP;
    }

    _cairo_surface_init (&surface->base,
                         &cairo_ps_surface_backend,
                         NULL, /* device */
                         CAIRO_CONTENT_COLOR_ALPHA);

    surface->final_stream = stream;

    surface->tmpfile = tmpfile ();
    if (surface->tmpfile == NULL) {
        switch (errno) {
        case ENOMEM:
            status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
            break;
        default:
            status = _cairo_error (CAIRO_STATUS_TEMP_FILE_ERROR);
            break;
        }
        goto CLEANUP_SURFACE;
    }

    surface->stream = _cairo_output_stream_create_for_file (surface->tmpfile);
    status = _cairo_output_stream_get_status (surface->stream);
    if (unlikely (status))
        goto CLEANUP_OUTPUT_STREAM;

    surface->font_subsets = _cairo_scaled_font_subsets_create_simple ();
    if (unlikely (surface->font_subsets == NULL)) {
        status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
        goto CLEANUP_OUTPUT_STREAM;
    }

    _cairo_scaled_font_subsets_enable_latin_subset (surface->font_subsets, TRUE);
    surface->has_creation_date = FALSE;
    surface->eps = FALSE;
    surface->ps_level = CAIRO_PS_LEVEL_3;
    surface->ps_level_used = CAIRO_PS_LEVEL_2;
    surface->width  = width;
    surface->height = height;
    cairo_matrix_init (&surface->cairo_to_ps, 1, 0, 0, -1, 0, height);
    surface->paginated_mode = CAIRO_PAGINATED_MODE_ANALYZE;
    surface->force_fallbacks = FALSE;
    surface->content = CAIRO_CONTENT_COLOR_ALPHA;
    surface->use_string_datasource = FALSE;
    surface->current_pattern_is_solid_color = FALSE;

    surface->page_bbox.x = 0;
    surface->page_bbox.y = 0;
    surface->page_bbox.width  = width;
    surface->page_bbox.height = height;

    _cairo_surface_clipper_init (&surface->clipper,
                                 _cairo_ps_surface_clipper_intersect_clip_path);

    _cairo_pdf_operators_init (&surface->pdf_operators,
                               surface->stream,
                               &surface->cairo_to_ps,
                               surface->font_subsets,
                               TRUE);
    surface->num_pages = 0;

    cairo_list_init (&surface->document_media);
    _cairo_array_init (&surface->dsc_header_comments, sizeof (char *));
    _cairo_array_init (&surface->dsc_setup_comments, sizeof (char *));
    _cairo_array_init (&surface->dsc_page_setup_comments, sizeof (char *));

    surface->dsc_comment_target = &surface->dsc_header_comments;

    surface->paginated_surface = _cairo_paginated_surface_create (
                                           &surface->base,
                                           CAIRO_CONTENT_COLOR_ALPHA,
                                           &cairo_ps_surface_paginated_backend);
    status = surface->paginated_surface->status;
    if (status == CAIRO_STATUS_SUCCESS) {
        /* paginated keeps the only reference to surface now, drop ours */
        cairo_surface_destroy (&surface->base);
        return surface->paginated_surface;
    }

    _cairo_scaled_font_subsets_destroy (surface->font_subsets);
 CLEANUP_OUTPUT_STREAM:
    status_ignored = _cairo_output_stream_destroy (surface->stream);
    fclose (surface->tmpfile);
 CLEANUP_SURFACE:
    free (surface);
 CLEANUP:
    /* destroy stream on behalf of caller */
    status_ignored = _cairo_output_stream_destroy (stream);

    return _cairo_surface_create_in_error (status);
}

/**
 * cairo_ps_surface_create:
 * @filename: a filename for the PS output (must be writable), %NULL may be
 *            used to specify no output. This will generate a PS surface that
 *            may be queried and used as a source, without generating a
 *            temporary file.
 * @width_in_points: width of the surface, in points (1 point == 1/72.0 inch)
 * @height_in_points: height of the surface, in points (1 point == 1/72.0 inch)
 *
 * Creates a PostScript surface of the specified size in points to be
 * written to @filename. See cairo_ps_surface_create_for_stream() for
 * a more flexible mechanism for handling the PostScript output than
 * simply writing it to a named file.
 *
 * Note that the size of individual pages of the PostScript output can
 * vary. See cairo_ps_surface_set_size().
 *
 * Return value: a pointer to the newly created surface. The caller
 * owns the surface and should call cairo_surface_destroy() when done
 * with it.
 *
 * This function always returns a valid pointer, but it will return a
 * pointer to a "nil" surface if an error such as out of memory
 * occurs. You can use cairo_surface_status() to check for this.
 *
 * Since: 1.2
 **/
cairo_surface_t *
cairo_ps_surface_create (const char             *filename,
                         double                  width_in_points,
                         double                  height_in_points)
{
    cairo_output_stream_t *stream;

    stream = _cairo_output_stream_create_for_filename (filename);
    if (_cairo_output_stream_get_status (stream))
        return _cairo_surface_create_in_error (_cairo_output_stream_destroy (stream));

    return _cairo_ps_surface_create_for_stream_internal (stream,
                                                         width_in_points,
                                                         height_in_points);
}

/**
 * cairo_ps_surface_create_for_stream:
 * @write_func: a #cairo_write_func_t to accept the output data, may be %NULL
 *              to indicate a no-op @write_func. With a no-op @write_func,
 *              the surface may be queried or used as a source without
 *              generating any temporary files.
 * @closure: the closure argument for @write_func
 * @width_in_points: width of the surface, in points (1 point == 1/72.0 inch)
 * @height_in_points: height of the surface, in points (1 point == 1/72.0 inch)
 *
 * Creates a PostScript surface of the specified size in points to be
 * written incrementally to the stream represented by @write_func and
 * @closure. See cairo_ps_surface_create() for a more convenient way
 * to simply direct the PostScript output to a named file.
 *
 * Note that the size of individual pages of the PostScript
 * output can vary. See cairo_ps_surface_set_size().
 *
 * Return value: a pointer to the newly created surface. The caller
 * owns the surface and should call cairo_surface_destroy() when done
 * with it.
 *
 * This function always returns a valid pointer, but it will return a
 * pointer to a "nil" surface if an error such as out of memory
 * occurs. You can use cairo_surface_status() to check for this.
 *
 * Since: 1.2
 **/
cairo_surface_t *
cairo_ps_surface_create_for_stream (cairo_write_func_t  write_func,
                                    void               *closure,
                                    double              width_in_points,
                                    double              height_in_points)
{
    cairo_output_stream_t *stream;

    stream = _cairo_output_stream_create (write_func, NULL, closure);
    if (_cairo_output_stream_get_status (stream))
        return _cairo_surface_create_in_error (_cairo_output_stream_destroy (stream));

    return _cairo_ps_surface_create_for_stream_internal (stream,
                                                         width_in_points,
                                                         height_in_points);
}

static cairo_bool_t
_cairo_surface_is_ps (cairo_surface_t *surface)
{
    return surface->backend == &cairo_ps_surface_backend;
}

/* If the abstract_surface is a paginated surface, and that paginated
 * surface's target is a ps_surface, then set ps_surface to that
 * target. Otherwise return FALSE.
 */
static cairo_bool_t
_extract_ps_surface (cairo_surface_t     *surface,
                     cairo_bool_t         set_error_on_failure,
                     cairo_ps_surface_t **ps_surface)
{
    cairo_surface_t *target;

    if (surface->status)
        return FALSE;
    if (surface->finished) {
        if (set_error_on_failure)
            _cairo_surface_set_error (surface,
                                      _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
        return FALSE;
    }

    if (! _cairo_surface_is_paginated (surface)) {
        if (set_error_on_failure)
            _cairo_surface_set_error (surface,
                                      _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH));
        return FALSE;
    }

    target = _cairo_paginated_surface_get_target (surface);
    if (target->status) {
        if (set_error_on_failure)
            _cairo_surface_set_error (surface, target->status);
        return FALSE;
    }
    if (target->finished) {
        if (set_error_on_failure)
            _cairo_surface_set_error (surface,
                                      _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
        return FALSE;
    }

    if (! _cairo_surface_is_ps (target)) {
        if (set_error_on_failure)
            _cairo_surface_set_error (surface,
                                      _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH));
        return FALSE;
    }

    *ps_surface = (cairo_ps_surface_t *) target;
    return TRUE;
}

/**
 * cairo_ps_surface_restrict_to_level:
 * @surface: a PostScript #cairo_surface_t
 * @level: PostScript level
 *
 * Restricts the generated PostSript file to @level. See
 * cairo_ps_get_levels() for a list of available level values that
 * can be used here.
 *
 * This function should only be called before any drawing operations
 * have been performed on the given surface. The simplest way to do
 * this is to call this function immediately after creating the
 * surface.
 *
 * Since: 1.6
 **/
void
cairo_ps_surface_restrict_to_level (cairo_surface_t  *surface,
                                    cairo_ps_level_t  level)
{
    cairo_ps_surface_t *ps_surface = NULL;

    if (! _extract_ps_surface (surface, TRUE, &ps_surface))
        return;

    if (level < CAIRO_PS_LEVEL_LAST)
        ps_surface->ps_level = level;
}

/**
 * cairo_ps_get_levels:
 * @levels: supported level list
 * @num_levels: list length
 *
 * Used to retrieve the list of supported levels. See
 * cairo_ps_surface_restrict_to_level().
 *
 * Since: 1.6
 **/
void
cairo_ps_get_levels (cairo_ps_level_t const     **levels,
                     int                         *num_levels)
{
    if (levels != NULL)
        *levels = _cairo_ps_levels;

    if (num_levels != NULL)
        *num_levels = CAIRO_PS_LEVEL_LAST;
}

/**
 * cairo_ps_level_to_string:
 * @level: a level id
 *
 * Get the string representation of the given @level id. This function
 * will return %NULL if @level id isn't valid. See cairo_ps_get_levels()
 * for a way to get the list of valid level ids.
 *
 * Return value: the string associated to given level.
 *
 * Since: 1.6
 **/
const char *
cairo_ps_level_to_string (cairo_ps_level_t level)
{
    if (level >= CAIRO_PS_LEVEL_LAST)
        return NULL;

    return _cairo_ps_level_strings[level];
}

/**
 * cairo_ps_surface_set_eps:
 * @surface: a PostScript #cairo_surface_t
 * @eps: %TRUE to output EPS format PostScript
 *
 * If @eps is %TRUE, the PostScript surface will output Encapsulated
 * PostScript.
 *
 * This function should only be called before any drawing operations
 * have been performed on the current page. The simplest way to do
 * this is to call this function immediately after creating the
 * surface. An Encapsulated PostScript file should never contain more
 * than one page.
 *
 * Since: 1.6
 **/
void
cairo_ps_surface_set_eps (cairo_surface_t       *surface,
                          cairo_bool_t           eps)
{
    cairo_ps_surface_t *ps_surface = NULL;

    if (! _extract_ps_surface (surface, TRUE, &ps_surface))
        return;

    ps_surface->eps = eps;
}

/**
 * cairo_ps_surface_get_eps:
 * @surface: a PostScript #cairo_surface_t
 *
 * Check whether the PostScript surface will output Encapsulated PostScript.
 *
 * Return value: %TRUE if the surface will output Encapsulated PostScript.
 *
 * Since: 1.6
 **/
cairo_public cairo_bool_t
cairo_ps_surface_get_eps (cairo_surface_t       *surface)
{
    cairo_ps_surface_t *ps_surface = NULL;

    if (! _extract_ps_surface (surface, FALSE, &ps_surface))
        return FALSE;

    return ps_surface->eps;
}

/**
 * cairo_ps_surface_set_size:
 * @surface: a PostScript #cairo_surface_t
 * @width_in_points: new surface width, in points (1 point == 1/72.0 inch)
 * @height_in_points: new surface height, in points (1 point == 1/72.0 inch)
 *
 * Changes the size of a PostScript surface for the current (and
 * subsequent) pages.
 *
 * This function should only be called before any drawing operations
 * have been performed on the current page. The simplest way to do
 * this is to call this function immediately after creating the
 * surface or immediately after completing a page with either
 * cairo_show_page() or cairo_copy_page().
 *
 * Since: 1.2
 **/
void
cairo_ps_surface_set_size (cairo_surface_t      *surface,
                           double                width_in_points,
                           double                height_in_points)
{
    cairo_ps_surface_t *ps_surface = NULL;
    cairo_status_t status;

    if (! _extract_ps_surface (surface, TRUE, &ps_surface))
        return;

    ps_surface->width = width_in_points;
    ps_surface->height = height_in_points;
    cairo_matrix_init (&ps_surface->cairo_to_ps, 1, 0, 0, -1, 0, height_in_points);
    _cairo_pdf_operators_set_cairo_to_pdf_matrix (&ps_surface->pdf_operators,
                                                  &ps_surface->cairo_to_ps);
    status = _cairo_paginated_surface_set_size (ps_surface->paginated_surface,
                                                width_in_points,
                                                height_in_points);
    if (status)
        status = _cairo_surface_set_error (surface, status);
}

/**
 * cairo_ps_surface_dsc_comment:
 * @surface: a PostScript #cairo_surface_t
 * @comment: a comment string to be emitted into the PostScript output
 *
 * Emit a comment into the PostScript output for the given surface.
 *
 * The comment is expected to conform to the PostScript Language
 * Document Structuring Conventions (DSC). Please see that manual for
 * details on the available comments and their meanings. In
 * particular, the \%\%IncludeFeature comment allows a
 * device-independent means of controlling printer device features. So
 * the PostScript Printer Description Files Specification will also be
 * a useful reference.
 *
 * The comment string must begin with a percent character (\%) and the
 * total length of the string (including any initial percent
 * characters) must not exceed 255 characters. Violating either of
 * these conditions will place @surface into an error state. But
 * beyond these two conditions, this function will not enforce
 * conformance of the comment with any particular specification.
 *
 * The comment string should not have a trailing newline.
 *
 * The DSC specifies different sections in which particular comments
 * can appear. This function provides for comments to be emitted
 * within three sections: the header, the Setup section, and the
 * PageSetup section.  Comments appearing in the first two sections
 * apply to the entire document while comments in the BeginPageSetup
 * section apply only to a single page.
 *
 * For comments to appear in the header section, this function should
 * be called after the surface is created, but before a call to
 * cairo_ps_surface_dsc_begin_setup().
 *
 * For comments to appear in the Setup section, this function should
 * be called after a call to cairo_ps_surface_dsc_begin_setup() but
 * before a call to cairo_ps_surface_dsc_begin_page_setup().
 *
 * For comments to appear in the PageSetup section, this function
 * should be called after a call to
 * cairo_ps_surface_dsc_begin_page_setup().
 *
 * Note that it is only necessary to call
 * cairo_ps_surface_dsc_begin_page_setup() for the first page of any
 * surface. After a call to cairo_show_page() or cairo_copy_page()
 * comments are unambiguously directed to the PageSetup section of the
 * current page. But it doesn't hurt to call this function at the
 * beginning of every page as that consistency may make the calling
 * code simpler.
 *
 * As a final note, cairo automatically generates several comments on
 * its own. As such, applications must not manually generate any of
 * the following comments:
 *
 * Header section: \%!PS-Adobe-3.0, \%\%Creator, \%\%CreationDate, \%\%Pages,
 * \%\%BoundingBox, \%\%DocumentData, \%\%LanguageLevel, \%\%EndComments.
 *
 * Setup section: \%\%BeginSetup, \%\%EndSetup
 *
 * PageSetup section: \%\%BeginPageSetup, \%\%PageBoundingBox, \%\%EndPageSetup.
 *
 * Other sections: \%\%BeginProlog, \%\%EndProlog, \%\%Page, \%\%Trailer, \%\%EOF
 *
 * Here is an example sequence showing how this function might be used:
 *
 * <informalexample><programlisting>
 * cairo_surface_t *surface = cairo_ps_surface_create (filename, width, height);
 * ...
 * cairo_ps_surface_dsc_comment (surface, "%%Title: My excellent document");
 * cairo_ps_surface_dsc_comment (surface, "%%Copyright: Copyright (C) 2006 Cairo Lover")
 * ...
 * cairo_ps_surface_dsc_begin_setup (surface);
 * cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *MediaColor White");
 * ...
 * cairo_ps_surface_dsc_begin_page_setup (surface);
 * cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *PageSize A3");
 * cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *InputSlot LargeCapacity");
 * cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *MediaType Glossy");
 * cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *MediaColor Blue");
 * ... draw to first page here ..
 * cairo_show_page (cr);
 * ...
 * cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *PageSize A5");
 * ...
 * </programlisting></informalexample>
 *
 * Since: 1.2
 **/
void
cairo_ps_surface_dsc_comment (cairo_surface_t   *surface,
                              const char        *comment)
{
    cairo_ps_surface_t *ps_surface = NULL;
    cairo_status_t status;
    char *comment_copy;

    if (! _extract_ps_surface (surface, TRUE, &ps_surface))
        return;

    /* A couple of sanity checks on the comment value. */
    if (comment == NULL) {
        status = _cairo_surface_set_error (surface, CAIRO_STATUS_NULL_POINTER);
        return;
    }

    if (comment[0] != '%' || strlen (comment) > 255) {
        status = _cairo_surface_set_error (surface, CAIRO_STATUS_INVALID_DSC_COMMENT);
        return;
    }

    /* Then, copy the comment and store it in the appropriate array. */
    comment_copy = strdup (comment);
    if (unlikely (comment_copy == NULL)) {
        status = _cairo_surface_set_error (surface, CAIRO_STATUS_NO_MEMORY);
        return;
    }

    status = _cairo_array_append (ps_surface->dsc_comment_target, &comment_copy);
    if (unlikely (status)) {
        free (comment_copy);
        status = _cairo_surface_set_error (surface, status);
        return;
    }
}

/**
 * cairo_ps_surface_dsc_begin_setup:
 * @surface: a PostScript #cairo_surface_t
 *
 * This function indicates that subsequent calls to
 * cairo_ps_surface_dsc_comment() should direct comments to the Setup
 * section of the PostScript output.
 *
 * This function should be called at most once per surface, and must
 * be called before any call to cairo_ps_surface_dsc_begin_page_setup()
 * and before any drawing is performed to the surface.
 *
 * See cairo_ps_surface_dsc_comment() for more details.
 *
 * Since: 1.2
 **/
void
cairo_ps_surface_dsc_begin_setup (cairo_surface_t *surface)
{
    cairo_ps_surface_t *ps_surface = NULL;

    if (! _extract_ps_surface (surface, TRUE, &ps_surface))
        return;

    if (ps_surface->dsc_comment_target == &ps_surface->dsc_header_comments)
        ps_surface->dsc_comment_target = &ps_surface->dsc_setup_comments;
}

/**
 * cairo_ps_surface_dsc_begin_page_setup:
 * @surface: a PostScript #cairo_surface_t
 *
 * This function indicates that subsequent calls to
 * cairo_ps_surface_dsc_comment() should direct comments to the
 * PageSetup section of the PostScript output.
 *
 * This function call is only needed for the first page of a
 * surface. It should be called after any call to
 * cairo_ps_surface_dsc_begin_setup() and before any drawing is
 * performed to the surface.
 *
 * See cairo_ps_surface_dsc_comment() for more details.
 *
 * Since: 1.2
 **/
void
cairo_ps_surface_dsc_begin_page_setup (cairo_surface_t *surface)
{
    cairo_ps_surface_t *ps_surface = NULL;

    if (! _extract_ps_surface (surface, TRUE, &ps_surface))
        return;

    if (ps_surface->dsc_comment_target == &ps_surface->dsc_header_comments ||
        ps_surface->dsc_comment_target == &ps_surface->dsc_setup_comments)
    {
        ps_surface->dsc_comment_target = &ps_surface->dsc_page_setup_comments;
    }
}

static cairo_status_t
_cairo_ps_surface_finish (void *abstract_surface)
{
    cairo_status_t status, status2;
    cairo_ps_surface_t *surface = abstract_surface;
    int i, num_comments;
    char **comments;

    status = surface->base.status;
    if (unlikely (status))
        goto CLEANUP;

    _cairo_ps_surface_emit_header (surface);

    status = _cairo_ps_surface_emit_font_subsets (surface);
    if (unlikely (status))
        goto CLEANUP;

    _cairo_output_stream_printf (surface->final_stream,
                                 "%%%%EndSetup\n");

    status = _cairo_ps_surface_emit_body (surface);
    if (unlikely (status))
        goto CLEANUP;

    _cairo_ps_surface_emit_footer (surface);

CLEANUP:
    _cairo_scaled_font_subsets_destroy (surface->font_subsets);

    status2 = _cairo_output_stream_destroy (surface->stream);
    if (status == CAIRO_STATUS_SUCCESS)
        status = status2;

    fclose (surface->tmpfile);

    status2 = _cairo_output_stream_destroy (surface->final_stream);
    if (status == CAIRO_STATUS_SUCCESS)
        status = status2;

    while (! cairo_list_is_empty (&surface->document_media)) {
        cairo_page_media_t *page;

        page = cairo_list_first_entry (&surface->document_media,
                                       cairo_page_media_t,
                                       link);
        cairo_list_del (&page->link);
        free (page->name);
        free (page);
    }

    num_comments = _cairo_array_num_elements (&surface->dsc_header_comments);
    comments = _cairo_array_index (&surface->dsc_header_comments, 0);
    for (i = 0; i < num_comments; i++)
        free (comments[i]);
    _cairo_array_fini (&surface->dsc_header_comments);

    num_comments = _cairo_array_num_elements (&surface->dsc_setup_comments);
    comments = _cairo_array_index (&surface->dsc_setup_comments, 0);
    for (i = 0; i < num_comments; i++)
        free (comments[i]);
    _cairo_array_fini (&surface->dsc_setup_comments);

    num_comments = _cairo_array_num_elements (&surface->dsc_page_setup_comments);
    comments = _cairo_array_index (&surface->dsc_page_setup_comments, 0);
    for (i = 0; i < num_comments; i++)
        free (comments[i]);
    _cairo_array_fini (&surface->dsc_page_setup_comments);

    _cairo_surface_clipper_reset (&surface->clipper);

    return status;
}

static cairo_int_status_t
_cairo_ps_surface_start_page (void *abstract_surface)
{
    cairo_ps_surface_t *surface = abstract_surface;

    /* Increment before print so page numbers start at 1. */
    surface->num_pages++;

    return CAIRO_STATUS_SUCCESS;
}

static cairo_int_status_t
_cairo_ps_surface_show_page (void *abstract_surface)
{
    cairo_ps_surface_t *surface = abstract_surface;
    cairo_int_status_t status;

    if (surface->clipper.clip != NULL)
        _cairo_surface_clipper_reset (&surface->clipper);

    status = _cairo_pdf_operators_flush (&surface->pdf_operators);
    if (unlikely (status))
        return status;

    _cairo_output_stream_printf (surface->stream,
                                 "Q Q\n"
                                 "showpage\n");

    return CAIRO_STATUS_SUCCESS;
}

static cairo_bool_t
color_is_gray (double red, double green, double blue)
{
    const double epsilon = 0.00001;

    return (fabs (red - green) < epsilon &&
            fabs (red - blue) < epsilon);
}

/**
 * _cairo_ps_surface_acquire_source_surface_from_pattern:
 * @surface: the ps surface
 * @pattern: A #cairo_pattern_t of type SURFACE or RASTER_SOURCE to use as the source
 * @extents: extents of the operation that is using this source
 * @width: returns width of surface
 * @height: returns height of surface
 * @x_offset: returns x offset of surface
 * @y_offset: returns y offset of surface
 * @surface: returns surface of type image surface or recording surface
 * @image_extra: returns image extra for image type surface
 *
 * Acquire source surface or raster source pattern.
 **/
static cairo_status_t
_cairo_ps_surface_acquire_source_surface_from_pattern (cairo_ps_surface_t           *surface,
                                                       const cairo_pattern_t        *pattern,
                                                       const cairo_rectangle_int_t  *extents,
                                                       int                          *width,
                                                       int                          *height,
                                                       double                       *x_offset,
                                                       double                       *y_offset,
                                                       cairo_surface_t             **source_surface,
                                                       void                        **image_extra)
{
    cairo_status_t          status;
    cairo_image_surface_t  *image;

    *x_offset = *y_offset = 0;
    switch (pattern->type) {
    case CAIRO_PATTERN_TYPE_SURFACE: {
        cairo_surface_t *surf = ((cairo_surface_pattern_t *) pattern)->surface;

        if (surf->type == CAIRO_SURFACE_TYPE_RECORDING) {
            if (surf->backend->type == CAIRO_SURFACE_TYPE_SUBSURFACE) {
                cairo_surface_subsurface_t *sub = (cairo_surface_subsurface_t *) surf;

                *width  = sub->extents.width;
                *height = sub->extents.height;
            } else {
                cairo_surface_t *free_me = NULL;
                cairo_recording_surface_t *recording_surface;
                cairo_box_t bbox;
                cairo_rectangle_int_t extents;

                recording_surface = (cairo_recording_surface_t *) surf;
                if (_cairo_surface_is_snapshot (&recording_surface->base)) {
                    free_me = _cairo_surface_snapshot_get_target (&recording_surface->base);
                    recording_surface = (cairo_recording_surface_t *) free_me;
                }

                status = _cairo_recording_surface_get_bbox (recording_surface, &bbox, NULL);
                cairo_surface_destroy (free_me);
                if (unlikely (status))
                    return status;

                _cairo_box_round_to_rectangle (&bbox, &extents);
                *width  = extents.width;
                *height = extents.height;
            }
            *source_surface = surf;

            return CAIRO_STATUS_SUCCESS;
        } else {
            status =  _cairo_surface_acquire_source_image (surf, &image, image_extra);
            if (unlikely (status))
                return status;
        }
    } break;

    case CAIRO_PATTERN_TYPE_RASTER_SOURCE: {
        cairo_surface_t *surf;
        cairo_box_t box;
        cairo_rectangle_int_t rect;

        /* get the operation extents in pattern space */
        _cairo_box_from_rectangle (&box, extents);
        _cairo_matrix_transform_bounding_box_fixed (&pattern->matrix, &box, NULL);
        _cairo_box_round_to_rectangle (&box, &rect);
        surf = _cairo_raster_source_pattern_acquire (pattern, &surface->base, &rect);
        if (!surf)
            return CAIRO_INT_STATUS_UNSUPPORTED;
        assert (_cairo_surface_is_image (surf));
        image = (cairo_image_surface_t *) surf;
    } break;

    case CAIRO_PATTERN_TYPE_SOLID:
    case CAIRO_PATTERN_TYPE_LINEAR:
    case CAIRO_PATTERN_TYPE_RADIAL:
    case CAIRO_PATTERN_TYPE_MESH:
    default:
        ASSERT_NOT_REACHED;
        break;
    }

    *width = image->width;
    *height = image->height;
    *source_surface = &image->base;
    return CAIRO_STATUS_SUCCESS;
}

static void
_cairo_ps_surface_release_source_surface_from_pattern (cairo_ps_surface_t           *surface,
                                                       const cairo_pattern_t        *pattern,
                                                       cairo_surface_t              *source,
                                                       void                         *image_extra)
{
    switch (pattern->type) {
    case CAIRO_PATTERN_TYPE_SURFACE: {
        cairo_surface_pattern_t *surf_pat = (cairo_surface_pattern_t *) pattern;
        if (surf_pat->surface->type != CAIRO_SURFACE_TYPE_RECORDING) {
            cairo_image_surface_t *image  = (cairo_image_surface_t *) source;
            _cairo_surface_release_source_image (surf_pat->surface, image, image_extra);
        }
    } break;

    case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
        _cairo_raster_source_pattern_release (pattern, source);
        break;

    case CAIRO_PATTERN_TYPE_SOLID:
    case CAIRO_PATTERN_TYPE_LINEAR:
    case CAIRO_PATTERN_TYPE_RADIAL:
    case CAIRO_PATTERN_TYPE_MESH:
    default:

        ASSERT_NOT_REACHED;
        break;
    }
}

/**
 * _cairo_ps_surface_create_padded_image_from_image:
 * @surface: the ps surface
 * @source: The source image
 * @extents: extents of the operation that is using this source
 * @width: returns width of padded image
 * @height: returns height of padded image
 * @x_offset: returns x offset of padded image
 * @y_offset: returns y offset of padded image
 * @image: returns the padded image or NULL if padding not required to fill @extents
 *
 * Creates a padded image if the source image does not fill the extents.
 **/
static cairo_status_t
_cairo_ps_surface_create_padded_image_from_image (cairo_ps_surface_t           *surface,
                                                  cairo_image_surface_t        *source,
                                                  const cairo_matrix_t         *source_matrix,
                                                  const cairo_rectangle_int_t  *extents,
                                                  int                          *width,
                                                  int                          *height,
                                                  double                       *x_offset,
                                                  double                       *y_offset,
                                                  cairo_image_surface_t       **image)
{
    cairo_box_t box;
    cairo_rectangle_int_t rect;
    cairo_surface_t        *pad_image;
    cairo_surface_pattern_t pad_pattern;
    int w, h;
    cairo_int_status_t      status;

    /* get the operation extents in pattern space */
    _cairo_box_from_rectangle (&box, extents);
    _cairo_matrix_transform_bounding_box_fixed (source_matrix, &box, NULL);
    _cairo_box_round_to_rectangle (&box, &rect);

    /* Check if image needs padding to fill extents. */
    w = source->width;
    h = source->height;
    if (_cairo_fixed_integer_ceil(box.p1.x) < 0 ||
        _cairo_fixed_integer_ceil(box.p1.y) < 0 ||
        _cairo_fixed_integer_floor(box.p2.y) > w ||
        _cairo_fixed_integer_floor(box.p2.y) > h)
    {
        pad_image =
            _cairo_image_surface_create_with_pixman_format (NULL,
                                                            source->pixman_format,
                                                            rect.width, rect.height,
                                                            0);
        if (pad_image->status)
            return pad_image->status;

        _cairo_pattern_init_for_surface (&pad_pattern, &source->base);
        cairo_matrix_init_translate (&pad_pattern.base.matrix, rect.x, rect.y);
        pad_pattern.base.extend = CAIRO_EXTEND_PAD;
        status = _cairo_surface_paint (pad_image,
                                       CAIRO_OPERATOR_SOURCE,
                                       &pad_pattern.base,
                                       NULL);
        _cairo_pattern_fini (&pad_pattern.base);
        *image = (cairo_image_surface_t *) pad_image;
        *width = rect.width;
        *height = rect.height;
        *x_offset = rect.x;
        *y_offset = rect.y;
    } else {
        *image = NULL;
        status = CAIRO_STATUS_SUCCESS;
    }

    return status;
}

static cairo_int_status_t
_cairo_ps_surface_analyze_surface_pattern_transparency (cairo_ps_surface_t            *surface,
                                                        const cairo_pattern_t         *pattern,
                                                        const cairo_rectangle_int_t   *extents)
{
    int width, height;
    double x_offset, y_offset;
    cairo_surface_t *source;
    cairo_image_surface_t *image;
    void *image_extra;
    cairo_int_status_t      status;
    cairo_image_transparency_t transparency;

    status = _cairo_ps_surface_acquire_source_surface_from_pattern (surface,
                                                                    pattern,
                                                                    extents,
                                                                    &width,
                                                                    &height,
                                                                    &x_offset,
                                                                    &y_offset,
                                                                    &source,
                                                                    &image_extra);
    if (unlikely (status))
        return status;

    image = (cairo_image_surface_t *) source;
    if (image->base.status)
        return image->base.status;

    transparency = _cairo_image_analyze_transparency (image);
    switch (transparency) {
    case CAIRO_IMAGE_IS_OPAQUE:
        status = CAIRO_STATUS_SUCCESS;
        break;

    case CAIRO_IMAGE_HAS_BILEVEL_ALPHA:
        if (surface->ps_level == CAIRO_PS_LEVEL_2) {
            status = CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY;
        } else {
            surface->ps_level_used = CAIRO_PS_LEVEL_3;
            status = CAIRO_STATUS_SUCCESS;
        }
        break;

    case CAIRO_IMAGE_HAS_ALPHA:
        status = CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY;
        break;

    case CAIRO_IMAGE_UNKNOWN:
        ASSERT_NOT_REACHED;
    }

    _cairo_ps_surface_release_source_surface_from_pattern (surface, pattern, source, image_extra);

    return status;
}

static cairo_bool_t
surface_pattern_supported (const cairo_surface_pattern_t *pattern)
{
    if (pattern->surface->type == CAIRO_SURFACE_TYPE_RECORDING)
        return TRUE;

    if (pattern->surface->backend->acquire_source_image == NULL)
        return FALSE;

    /* Does an ALPHA-only source surface even make sense? Maybe, but I
     * don't think it's worth the extra code to support it. */

/* XXX: Need to write this function here...
    content = pattern->surface->content;
    if (content == CAIRO_CONTENT_ALPHA)
        return FALSE;
*/

    return TRUE;
}

static cairo_bool_t
_gradient_pattern_supported (cairo_ps_surface_t    *surface,
                             const cairo_pattern_t *pattern)
{
    double min_alpha, max_alpha;

    if (surface->ps_level == CAIRO_PS_LEVEL_2)
        return FALSE;

    /* Alpha gradients are only supported (by flattening the alpha)
     * if there is no variation in the alpha across the gradient. */
    _cairo_pattern_alpha_range (pattern, &min_alpha, &max_alpha);
    if (min_alpha != max_alpha)
        return FALSE;

    surface->ps_level_used = CAIRO_PS_LEVEL_3;

    return TRUE;
}

static cairo_bool_t
pattern_supported (cairo_ps_surface_t *surface, const cairo_pattern_t *pattern)
{
    switch (pattern->type) {
    case CAIRO_PATTERN_TYPE_SOLID:
        return TRUE;

    case CAIRO_PATTERN_TYPE_LINEAR:
    case CAIRO_PATTERN_TYPE_RADIAL:
    case CAIRO_PATTERN_TYPE_MESH:
        return _gradient_pattern_supported (surface, pattern);

    case CAIRO_PATTERN_TYPE_SURFACE:
        return surface_pattern_supported ((cairo_surface_pattern_t *) pattern);

    case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
        return TRUE;

    default:
        ASSERT_NOT_REACHED;
        return FALSE;
    }
}

static cairo_bool_t
mask_supported (cairo_ps_surface_t *surface,
                const cairo_pattern_t *mask,
                const cairo_rectangle_int_t *extents)
{
    if (surface->ps_level == CAIRO_PS_LEVEL_2)
        return FALSE;

    if (mask->type == CAIRO_PATTERN_TYPE_SURFACE) {
        cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) mask;
        if (surface_pattern->surface->type == CAIRO_SURFACE_TYPE_IMAGE) {
            /* check if mask if opaque or bilevel alpha */
            if (_cairo_ps_surface_analyze_surface_pattern_transparency (surface, mask, extents) == CAIRO_INT_STATUS_SUCCESS) {
                surface->ps_level_used = CAIRO_PS_LEVEL_3;
                return TRUE;
            }
        }
    }

    return FALSE;
}

static cairo_int_status_t
_cairo_ps_surface_analyze_operation (cairo_ps_surface_t    *surface,
                                     cairo_operator_t       op,
                                     const cairo_pattern_t       *pattern,
                                     const cairo_pattern_t       *mask,
                                     const cairo_rectangle_int_t *extents)
{
    double min_alpha;

    if (surface->force_fallbacks &&
        surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE)
    {
        return CAIRO_INT_STATUS_UNSUPPORTED;
    }

    if (! pattern_supported (surface, pattern))
        return CAIRO_INT_STATUS_UNSUPPORTED;

    if (! (op == CAIRO_OPERATOR_SOURCE || op == CAIRO_OPERATOR_OVER))
        return CAIRO_INT_STATUS_UNSUPPORTED;

    /* Mask is only supported when the mask is an image with opaque or bilevel alpha. */
    if (mask && !mask_supported (surface, mask, extents))
        return CAIRO_INT_STATUS_UNSUPPORTED;

    if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE) {
        cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) pattern;

        if (surface_pattern->surface->type == CAIRO_SURFACE_TYPE_RECORDING) {
            if (pattern->extend == CAIRO_EXTEND_PAD) {
                cairo_box_t box;
                cairo_rectangle_int_t rect;
                cairo_rectangle_int_t rec_extents;

                /* get the operation extents in pattern space */
                _cairo_box_from_rectangle (&box, extents);
                _cairo_matrix_transform_bounding_box_fixed (&pattern->matrix, &box, NULL);
                _cairo_box_round_to_rectangle (&box, &rect);

                /* Check if surface needs padding to fill extents */
                if (_cairo_surface_get_extents (surface_pattern->surface, &rec_extents)) {
                    if (_cairo_fixed_integer_ceil(box.p1.x) < rec_extents.x ||
                        _cairo_fixed_integer_ceil(box.p1.y) < rec_extents.y ||
                        _cairo_fixed_integer_floor(box.p2.y) > rec_extents.x + rec_extents.width ||
                        _cairo_fixed_integer_floor(box.p2.y) > rec_extents.y + rec_extents.height)
                    {
                        return CAIRO_INT_STATUS_UNSUPPORTED;
                    }
                }
            }
            return CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN;
        }
    }

    if (op == CAIRO_OPERATOR_SOURCE) {
        if (mask)
            return CAIRO_INT_STATUS_UNSUPPORTED;
        else
            return CAIRO_STATUS_SUCCESS;
    }

    /* CAIRO_OPERATOR_OVER is only supported for opaque patterns. If
     * the pattern contains transparency, we return
     * CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY to the analysis
     * surface. If the analysis surface determines that there is
     * anything drawn under this operation, a fallback image will be
     * used. Otherwise the operation will be replayed during the
     * render stage and we blend the transparency into the white
     * background to convert the pattern to opaque.
     */
    if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE || pattern->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE)
        return _cairo_ps_surface_analyze_surface_pattern_transparency (surface, pattern, extents);

    /* Patterns whose drawn part is opaque are directly supported;
       those whose drawn part is partially transparent can be
       supported by flattening the alpha. */
    _cairo_pattern_alpha_range (pattern, &min_alpha, NULL);
    if (CAIRO_ALPHA_IS_OPAQUE (min_alpha))
        return CAIRO_STATUS_SUCCESS;

    return CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY;
}

static cairo_bool_t
_cairo_ps_surface_operation_supported (cairo_ps_surface_t    *surface,
                                       cairo_operator_t       op,
                                       const cairo_pattern_t       *pattern,
                                       const cairo_pattern_t       *mask,
                                       const cairo_rectangle_int_t *extents)
{
    return _cairo_ps_surface_analyze_operation (surface, op, pattern, mask, extents) != CAIRO_INT_STATUS_UNSUPPORTED;
}

/* The "standard" implementation limit for PostScript string sizes is
 * 65535 characters (see PostScript Language Reference, Appendix
 * B). We go one short of that because we sometimes need two
 * characters in a string to represent a single ASCII85 byte, (for the
 * escape sequences "\\", "\(", and "\)") and we must not split these
 * across two strings. So we'd be in trouble if we went right to the
 * limit and one of these escape sequences just happened to land at
 * the end.
 */
#define STRING_ARRAY_MAX_STRING_SIZE (65535-1)
#define STRING_ARRAY_MAX_COLUMN      72

typedef struct _string_array_stream {
    cairo_output_stream_t base;
    cairo_output_stream_t *output;
    int column;
    int string_size;
    cairo_bool_t use_strings;
} string_array_stream_t;

static cairo_status_t
_string_array_stream_write (cairo_output_stream_t *base,
                            const unsigned char   *data,
                            unsigned int           length)
{
    string_array_stream_t *stream = (string_array_stream_t *) base;
    unsigned char c;
    const unsigned char backslash = '\\';

    if (length == 0)
        return CAIRO_STATUS_SUCCESS;

    while (length--) {
        if (stream->string_size == 0 && stream->use_strings) {
            _cairo_output_stream_printf (stream->output, "(");
            stream->column++;
        }

        c = *data++;
        if (stream->use_strings) {
            switch (c) {
            case '\\':
            case '(':
            case ')':
                _cairo_output_stream_write (stream->output, &backslash, 1);
                stream->column++;
                stream->string_size++;
                break;
            }
        }
        /* Have to be careful to never split the final ~> sequence. */
        if (c == '~') {
            _cairo_output_stream_write (stream->output, &c, 1);
            stream->column++;
            stream->string_size++;

            if (length-- == 0)
                break;

            c = *data++;
        }
        _cairo_output_stream_write (stream->output, &c, 1);
        stream->column++;
        stream->string_size++;

        if (stream->use_strings &&
            stream->string_size >= STRING_ARRAY_MAX_STRING_SIZE)
        {
            _cairo_output_stream_printf (stream->output, ")\n");
            stream->string_size = 0;
            stream->column = 0;
        }
        if (stream->column >= STRING_ARRAY_MAX_COLUMN) {
            _cairo_output_stream_printf (stream->output, "\n ");
            stream->string_size += 2;
            stream->column = 1;
        }
    }

    return _cairo_output_stream_get_status (stream->output);
}

static cairo_status_t
_string_array_stream_close (cairo_output_stream_t *base)
{
    cairo_status_t status;
    string_array_stream_t *stream = (string_array_stream_t *) base;

    if (stream->use_strings)
        _cairo_output_stream_printf (stream->output, ")\n");

    status = _cairo_output_stream_get_status (stream->output);

    return status;
}

/* A string_array_stream wraps an existing output stream. It takes the
 * data provided to it and output one or more consecutive string
 * objects, each within the standard PostScript implementation limit
 * of 65k characters.
 *
 * The strings are each separated by a space character for easy
 * inclusion within an array object, (but the array delimiters are not
 * added by the string_array_stream).
 *
 * The string array stream is also careful to wrap the output within
 * STRING_ARRAY_MAX_COLUMN columns (+/- 1). The stream also adds
 * necessary escaping for special characters within a string,
 * (specifically '\', '(', and ')').
 */
static cairo_output_stream_t *
_string_array_stream_create (cairo_output_stream_t *output)
{
    string_array_stream_t *stream;

    stream = malloc (sizeof (string_array_stream_t));
    if (unlikely (stream == NULL)) {
        _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
        return (cairo_output_stream_t *) &_cairo_output_stream_nil;
    }

    _cairo_output_stream_init (&stream->base,
                               _string_array_stream_write,
                               NULL,
                               _string_array_stream_close);
    stream->output = output;
    stream->column = 0;
    stream->string_size = 0;
    stream->use_strings = TRUE;

    return &stream->base;
}

/* A base85_array_stream wraps an existing output stream. It wraps the
 * output within STRING_ARRAY_MAX_COLUMN columns (+/- 1). The output
 * is not enclosed in strings like string_array_stream.
 */
static cairo_output_stream_t *
_base85_array_stream_create (cairo_output_stream_t *output)
{
    string_array_stream_t *stream;

    stream = malloc (sizeof (string_array_stream_t));
    if (unlikely (stream == NULL)) {
        _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
        return (cairo_output_stream_t *) &_cairo_output_stream_nil;
    }

    _cairo_output_stream_init (&stream->base,
                               _string_array_stream_write,
                               NULL,
                               _string_array_stream_close);
    stream->output = output;
    stream->column = 0;
    stream->string_size = 0;
    stream->use_strings = FALSE;

    return &stream->base;
}


/* PS Output - this section handles output of the parts of the recording
 * surface we can render natively in PS. */

static cairo_status_t
_cairo_ps_surface_flatten_image_transparency (cairo_ps_surface_t    *surface,
                                              cairo_image_surface_t *image,
                                              cairo_image_surface_t **opaque_image)
{
    cairo_surface_t *opaque;
    cairo_surface_pattern_t pattern;
    cairo_status_t status;

    opaque = cairo_image_surface_create (CAIRO_FORMAT_RGB24,
                                         image->width,
                                         image->height);
    if (unlikely (opaque->status))
        return opaque->status;

    if (surface->content == CAIRO_CONTENT_COLOR_ALPHA) {
        status = _cairo_surface_paint (opaque,
                                       CAIRO_OPERATOR_SOURCE,
                                       &_cairo_pattern_white.base,
                                       NULL);
        if (unlikely (status)) {
            cairo_surface_destroy (opaque);
            return status;
        }
    }

    _cairo_pattern_init_for_surface (&pattern, &image->base);
    pattern.base.filter = CAIRO_FILTER_NEAREST;
    status = _cairo_surface_paint (opaque, CAIRO_OPERATOR_OVER, &pattern.base, NULL);
    _cairo_pattern_fini (&pattern.base);
    if (unlikely (status)) {
        cairo_surface_destroy (opaque);
        return status;
    }

    *opaque_image = (cairo_image_surface_t *) opaque;
    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_ps_surface_emit_base85_string (cairo_ps_surface_t    *surface,
                                      const unsigned char   *data,
                                      unsigned long          length,
                                      cairo_ps_compress_t    compress,
                                      cairo_bool_t           use_strings)
{
    cairo_output_stream_t *base85_stream, *string_array_stream, *deflate_stream;
    unsigned char *data_compressed;
    unsigned long data_compressed_size;
    cairo_status_t status, status2;

    if (use_strings)
        string_array_stream = _string_array_stream_create (surface->stream);
    else
        string_array_stream = _base85_array_stream_create (surface->stream);

    status = _cairo_output_stream_get_status (string_array_stream);
    if (unlikely (status))
        return _cairo_output_stream_destroy (string_array_stream);

    base85_stream = _cairo_base85_stream_create (string_array_stream);
    status = _cairo_output_stream_get_status (base85_stream);
    if (unlikely (status)) {
        status2 = _cairo_output_stream_destroy (string_array_stream);
        return _cairo_output_stream_destroy (base85_stream);
    }

    switch (compress) {
        case CAIRO_PS_COMPRESS_NONE:
            _cairo_output_stream_write (base85_stream, data, length);
            break;

        case CAIRO_PS_COMPRESS_LZW:
            /* XXX: Should fix cairo-lzw to provide a stream-based interface
             * instead. */
            data_compressed_size = length;
            data_compressed = _cairo_lzw_compress ((unsigned char*)data, &data_compressed_size);
            if (unlikely (data_compressed == NULL)) {
                status = _cairo_output_stream_destroy (string_array_stream);
                status = _cairo_output_stream_destroy (base85_stream);
                return _cairo_error (CAIRO_STATUS_NO_MEMORY);
            }
            _cairo_output_stream_write (base85_stream, data_compressed, data_compressed_size);
            free (data_compressed);
            break;

        case CAIRO_PS_COMPRESS_DEFLATE:
            deflate_stream = _cairo_deflate_stream_create (base85_stream);
            if (_cairo_output_stream_get_status (deflate_stream)) {
                return _cairo_output_stream_destroy (deflate_stream);
            }
            _cairo_output_stream_write (deflate_stream, data, length);
            status = _cairo_output_stream_destroy (deflate_stream);
            if (unlikely (status)) {
                status2 = _cairo_output_stream_destroy (string_array_stream);
                status2 = _cairo_output_stream_destroy (base85_stream);
                return _cairo_output_stream_destroy (deflate_stream);
            }
            break;
    }
    status = _cairo_output_stream_destroy (base85_stream);

    /* Mark end of base85 data */
    _cairo_output_stream_printf (string_array_stream, "~>");
    status2 = _cairo_output_stream_destroy (string_array_stream);
    if (status == CAIRO_STATUS_SUCCESS)
        status = status2;

    return status;
}

static cairo_status_t
_cairo_ps_surface_emit_image (cairo_ps_surface_t    *surface,
                              cairo_image_surface_t *image_surf,
                              cairo_operator_t       op,
                              cairo_filter_t         filter,
                              cairo_bool_t           stencil_mask)
{
    cairo_status_t status;
    unsigned char *data;
    unsigned long data_size;
    cairo_image_surface_t *ps_image;
    int x, y, i, a;
    cairo_image_transparency_t transparency;
    cairo_bool_t use_mask;
    uint32_t *pixel32;
    uint8_t *pixel8;
    int bit;
    cairo_image_color_t color;
    const char *interpolate;
    cairo_ps_compress_t compress;
    const char *compress_filter;
    cairo_image_surface_t *image;

    if (image_surf->base.status)
        return image_surf->base.status;

    image  = image_surf;
    if (image->format != CAIRO_FORMAT_RGB24 &&
        image->format != CAIRO_FORMAT_ARGB32 &&
        image->format != CAIRO_FORMAT_A8 &&
        image->format != CAIRO_FORMAT_A1)
    {
        cairo_surface_t *surf;
        cairo_surface_pattern_t pattern;

        surf = _cairo_image_surface_create_with_content (image_surf->base.content,
                                                         image_surf->width,
                                                         image_surf->height);
        image = (cairo_image_surface_t *) surf;
        if (surf->status) {
            status = surf->status;
            goto bail0;
        }

        _cairo_pattern_init_for_surface (&pattern, &image_surf->base);
        status = _cairo_surface_paint (surf,
                                       CAIRO_OPERATOR_SOURCE, &pattern.base,
                                       NULL);
        _cairo_pattern_fini (&pattern.base);
        if (unlikely (status))
            goto bail0;
    }
    ps_image = image;

    switch (filter) {
    default:
    case CAIRO_FILTER_GOOD:
    case CAIRO_FILTER_BEST:
    case CAIRO_FILTER_BILINEAR:
        interpolate = "true";
        break;
    case CAIRO_FILTER_FAST:
    case CAIRO_FILTER_NEAREST:
    case CAIRO_FILTER_GAUSSIAN:
        interpolate = "false";
        break;
    }

    if (stencil_mask) {
        use_mask = FALSE;
        color = CAIRO_IMAGE_IS_MONOCHROME;
        transparency = CAIRO_IMAGE_HAS_BILEVEL_ALPHA;
    } else {
        transparency = _cairo_image_analyze_transparency (image);

        /* PostScript can not represent the alpha channel, so we blend the
           current image over a white (or black for CONTENT_COLOR
           surfaces) RGB surface to eliminate it. */

        if (op == CAIRO_OPERATOR_SOURCE ||
            transparency == CAIRO_IMAGE_HAS_ALPHA ||
            (transparency == CAIRO_IMAGE_HAS_BILEVEL_ALPHA &&
             surface->ps_level == CAIRO_PS_LEVEL_2))
        {
            status = _cairo_ps_surface_flatten_image_transparency (surface,
                                                                   image,
                                                                   &ps_image);
            if (unlikely (status))
                return status;

            use_mask = FALSE;
        } else if (transparency == CAIRO_IMAGE_IS_OPAQUE) {
            use_mask = FALSE;
        } else { /* transparency == CAIRO_IMAGE_HAS_BILEVEL_ALPHA */
            use_mask = TRUE;
        }

        color = _cairo_image_analyze_color (ps_image);
    }

    /* Type 2 (mask and image interleaved) has the mask and image
     * samples interleaved by row.  The mask row is first, one bit per
     * pixel with (bit 7 first). The row is padded to byte
     * boundaries. The image data is 3 bytes per pixel RGB format. */
    switch (color) {
    default:
    case CAIRO_IMAGE_UNKNOWN_COLOR:
        ASSERT_NOT_REACHED;
    case CAIRO_IMAGE_IS_COLOR:
        data_size = ps_image->width * 3;
        break;
    case CAIRO_IMAGE_IS_GRAYSCALE:
        data_size = ps_image->width;
        break;
    case CAIRO_IMAGE_IS_MONOCHROME:
        data_size = (ps_image->width + 7)/8;
        break;
    }
    if (use_mask)
        data_size += (ps_image->width + 7)/8;
    data_size *= ps_image->height;
    data = malloc (data_size);
    if (unlikely (data == NULL)) {
        status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
        goto bail1;
    }

    i = 0;
    for (y = 0; y < ps_image->height; y++) {
        if (stencil_mask || use_mask) {
            /* mask row */
            if (ps_image->format == CAIRO_FORMAT_A1) {
                pixel8 = (uint8_t *) (ps_image->data + y * ps_image->stride);

                for (x = 0; x < (ps_image->width + 7) / 8; x++, pixel8++) {
                    a = *pixel8;
                    a = CAIRO_BITSWAP8_IF_LITTLE_ENDIAN (a);
                    data[i++] = a;
                }
            } else {
                pixel8 = (uint8_t *) (ps_image->data + y * ps_image->stride);
                pixel32 = (uint32_t *) (ps_image->data + y * ps_image->stride);
                bit = 7;
                for (x = 0; x < ps_image->width; x++) {
                    if (ps_image->format == CAIRO_FORMAT_ARGB32) {
                        a = (*pixel32 & 0xff000000) >> 24;
                        pixel32++;
                    } else {
                        a = *pixel8;
                        pixel8++;
                    }

                    if (transparency == CAIRO_IMAGE_HAS_ALPHA) {
                        data[i++] = a;
                    } else { /* transparency == CAIRO_IMAGE_HAS_BILEVEL_ALPHA or CAIRO_IMAGE_IS_OPAQUE */
                        if (bit == 7)
                            data[i] = 0;
                        if (a != 0)
                            data[i] |= (1 << bit);
                        bit--;
                        if (bit < 0) {
                            bit = 7;
                            i++;
                        }
                    }
                }
                if (bit != 7)
                    i++;
            }
        }
        if (stencil_mask)
            continue;

        /* image row*/
        pixel32 = (uint32_t *) (ps_image->data + y * ps_image->stride);
        bit = 7;
        for (x = 0; x < ps_image->width; x++, pixel32++) {
            int r, g, b;

            if (ps_image->format == CAIRO_FORMAT_ARGB32) {
                /* At this point ARGB32 images are either opaque or
                 * bilevel alpha so we don't need to unpremultiply. */
                if (((*pixel32 & 0xff000000) >> 24) == 0) {
                    r = g = b = 0;
                } else {
                    r = (*pixel32 & 0x00ff0000) >> 16;
                    g = (*pixel32 & 0x0000ff00) >>  8;
                    b = (*pixel32 & 0x000000ff) >>  0;
                }
            } else if (ps_image->format == CAIRO_FORMAT_RGB24) {
                r = (*pixel32 & 0x00ff0000) >> 16;
                g = (*pixel32 & 0x0000ff00) >>  8;
                b = (*pixel32 & 0x000000ff) >>  0;
            } else {
                r = g = b = 0;
            }

            switch (color) {
                case CAIRO_IMAGE_IS_COLOR:
                case CAIRO_IMAGE_UNKNOWN_COLOR:
                    data[i++] = r;
                    data[i++] = g;
                    data[i++] = b;
                    break;

                case CAIRO_IMAGE_IS_GRAYSCALE:
                    data[i++] = r;
                    break;

                case CAIRO_IMAGE_IS_MONOCHROME:
                    if (bit == 7)
                        data[i] = 0;
                    if (r != 0)
                        data[i] |= (1 << bit);
                    bit--;
                    if (bit < 0) {
                        bit = 7;
                        i++;
                    }
                    break;
            }
        }
        if (bit != 7)
            i++;
    }

    if (surface->ps_level == CAIRO_PS_LEVEL_2) {
        compress = CAIRO_PS_COMPRESS_LZW;
        compress_filter = "LZWDecode";
    } else {
        compress = CAIRO_PS_COMPRESS_DEFLATE;
        compress_filter = "FlateDecode";
        surface->ps_level_used = CAIRO_PS_LEVEL_3;
    }

    if (surface->use_string_datasource) {
        /* Emit the image data as a base85-encoded string which will
         * be used as the data source for the image operator later. */
        _cairo_output_stream_printf (surface->stream,
                                     "/CairoImageData [\n");

        status = _cairo_ps_surface_emit_base85_string (surface,
                                                       data,
                                                       data_size,
                                                       compress,
                                                       TRUE);
        if (unlikely (status))
            goto bail2;

        _cairo_output_stream_printf (surface->stream,
                                     "] def\n");
        _cairo_output_stream_printf (surface->stream,
                                     "/CairoImageDataIndex 0 def\n");
    }

    if (use_mask) {
        _cairo_output_stream_printf (surface->stream,
                                     "%s setcolorspace\n"
                                     "5 dict dup begin\n"
                                     "  /ImageType 3 def\n"
                                     "  /InterleaveType 2 def\n"
                                     "  /DataDict 8 dict def\n"
                                     "    DataDict begin\n"
                                     "    /ImageType 1 def\n"
                                     "    /Width %d def\n"
                                     "    /Height %d def\n"
                                     "    /Interpolate %s def\n"
                                     "    /BitsPerComponent %d def\n"
                                     "    /Decode [ %s ] def\n",
                                     color == CAIRO_IMAGE_IS_COLOR ? "/DeviceRGB" : "/DeviceGray",
                                     ps_image->width,
                                     ps_image->height,
                                     interpolate,
                                     color == CAIRO_IMAGE_IS_MONOCHROME ? 1 : 8,
                                     color == CAIRO_IMAGE_IS_COLOR ? "0 1 0 1 0 1" : "0 1");

        if (surface->use_string_datasource) {
            _cairo_output_stream_printf (surface->stream,
                                         "    /DataSource {\n"
                                         "      CairoImageData CairoImageDataIndex get\n"
                                         "      /CairoImageDataIndex CairoImageDataIndex 1 add def\n"
                                         "      CairoImageDataIndex CairoImageData length 1 sub gt\n"
                                         "       { /CairoImageDataIndex 0 def } if\n"
                                         "    } /ASCII85Decode filter /%s filter def\n",
                                         compress_filter);
        } else {
            _cairo_output_stream_printf (surface->stream,
                                         "    /DataSource currentfile /ASCII85Decode filter /%s filter def\n",
                                         compress_filter);
        }

        _cairo_output_stream_printf (surface->stream,
                                     "    /ImageMatrix [ 1 0 0 -1 0 %d ] def\n"
                                     "  end\n"
                                     "  /MaskDict 8 dict def\n"
                                     "     MaskDict begin\n"
                                     "    /ImageType 1 def\n"
                                     "    /Width %d def\n"
                                     "    /Height %d def\n"
                                     "    /Interpolate %s def\n"
                                     "    /BitsPerComponent 1 def\n"
                                     "    /Decode [ 1 0 ] def\n"
                                     "    /ImageMatrix [ 1 0 0 -1 0 %d ] def\n"
                                     "  end\n"
                                     "end\n"
                                     "image\n",
                                     ps_image->height,
                                     ps_image->width,
                                     ps_image->height,
                                     interpolate,
                                     ps_image->height);
    } else {
        if (!stencil_mask) {
            _cairo_output_stream_printf (surface->stream,
                                         "%s setcolorspace\n",
                                         color == CAIRO_IMAGE_IS_COLOR ? "/DeviceRGB" : "/DeviceGray");
        }
        _cairo_output_stream_printf (surface->stream,
                                     "8 dict dup begin\n"
                                     "  /ImageType 1 def\n"
                                     "  /Width %d def\n"
                                     "  /Height %d def\n"
                                     "  /Interpolate %s def\n"
                                     "  /BitsPerComponent %d def\n"
                                     "  /Decode [ %s ] def\n",
                                     ps_image->width,
                                     ps_image->height,
                                     interpolate,
                                     color == CAIRO_IMAGE_IS_MONOCHROME ? 1 : 8,
                                     stencil_mask ? "1 0" : color == CAIRO_IMAGE_IS_COLOR ? "0 1 0 1 0 1" : "0 1");
        if (surface->use_string_datasource) {
            _cairo_output_stream_printf (surface->stream,
                                         "  /DataSource {\n"
                                         "    CairoImageData CairoImageDataIndex get\n"
                                         "    /CairoImageDataIndex CairoImageDataIndex 1 add def\n"
                                         "    CairoImageDataIndex CairoImageData length 1 sub gt\n"
                                         "     { /CairoImageDataIndex 0 def } if\n"
                                         "  } /ASCII85Decode filter /%s filter def\n",
                                         compress_filter);
        } else {
            _cairo_output_stream_printf (surface->stream,
                                         "  /DataSource currentfile /ASCII85Decode filter /%s filter def\n",
                                         compress_filter);
        }

        _cairo_output_stream_printf (surface->stream,
                                     "  /ImageMatrix [ 1 0 0 -1 0 %d ] def\n"
                                     "end\n"
                                     "%s\n",
                                     ps_image->height,
                                     stencil_mask ? "imagemask" : "image");
    }

    if (!surface->use_string_datasource) {
        /* Emit the image data as a base85-encoded string which will
         * be used as the data source for the image operator. */
        status = _cairo_ps_surface_emit_base85_string (surface,
                                                       data,
                                                       data_size,
                                                       compress,
                                                       FALSE);
        _cairo_output_stream_printf (surface->stream, "\n");
    } else {
        status = CAIRO_STATUS_SUCCESS;
    }

bail2:
    free (data);

bail1:
    if (!use_mask && ps_image != image)
        cairo_surface_destroy (&ps_image->base);

bail0:
    if (image != image_surf)
        cairo_surface_destroy (&image->base);

    return status;
}

static cairo_status_t
_cairo_ps_surface_emit_jpeg_image (cairo_ps_surface_t    *surface,
                                   cairo_surface_t       *source,
                                   int                    width,
                                   int                    height)
{
    cairo_status_t status;
    const unsigned char *mime_data;
    unsigned long mime_data_length;
    cairo_image_info_t info;
    const char *colorspace;
    const char *decode;

    cairo_surface_get_mime_data (source, CAIRO_MIME_TYPE_JPEG,
                                 &mime_data, &mime_data_length);
    if (unlikely (source->status))
        return source->status;
    if (mime_data == NULL)
        return CAIRO_INT_STATUS_UNSUPPORTED;

    status = _cairo_image_info_get_jpeg_info (&info, mime_data, mime_data_length);
    if (unlikely (status))
        return status;

    switch (info.num_components) {
        case 1:
            colorspace = "/DeviceGray";
            decode = "0 1";
            break;
        case 3:
            colorspace = "/DeviceRGB";
            decode =  "0 1 0 1 0 1";
            break;
        case 4:
            colorspace = "/DeviceCMYK";
            decode =  "0 1 0 1 0 1 0 1";
            break;
        default:
            return CAIRO_INT_STATUS_UNSUPPORTED;
    }

    if (surface->use_string_datasource) {
        /* Emit the image data as a base85-encoded string which will
         * be used as the data source for the image operator later. */
        _cairo_output_stream_printf (surface->stream,
                                     "/CairoImageData [\n");

        status = _cairo_ps_surface_emit_base85_string (surface,
                                                       mime_data,
                                                       mime_data_length,
                                                       CAIRO_PS_COMPRESS_NONE,
                                                       TRUE);
        if (unlikely (status))
            return status;

        _cairo_output_stream_printf (surface->stream,
                                     "] def\n");
        _cairo_output_stream_printf (surface->stream,
                                     "/CairoImageDataIndex 0 def\n");
    }

    _cairo_output_stream_printf (surface->stream,
                                 "%s setcolorspace\n"
                                 "8 dict dup begin\n"
                                 "  /ImageType 1 def\n"
                                 "  /Width %d def\n"
                                 "  /Height %d def\n"
                                 "  /BitsPerComponent %d def\n"
                                 "  /Decode [ %s ] def\n",
                                 colorspace,
                                 info.width,
                                 info.height,
                                 info.bits_per_component,
                                 decode);

    if (surface->use_string_datasource) {
        _cairo_output_stream_printf (surface->stream,
                                     "  /DataSource {\n"
                                     "    CairoImageData CairoImageDataIndex get\n"
                                     "    /CairoImageDataIndex CairoImageDataIndex 1 add def\n"
                                     "    CairoImageDataIndex CairoImageData length 1 sub gt\n"
                                     "     { /CairoImageDataIndex 0 def } if\n"
                                     "  } /ASCII85Decode filter /DCTDecode filter def\n");
    } else {
        _cairo_output_stream_printf (surface->stream,
                                     "  /DataSource currentfile /ASCII85Decode filter /DCTDecode filter def\n");
    }

    _cairo_output_stream_printf (surface->stream,
                                 "  /ImageMatrix [ 1 0 0 -1 0 %d ] def\n"
                                 "end\n"
                                 "image\n",
                                 info.height);

    if (!surface->use_string_datasource) {
        /* Emit the image data as a base85-encoded string which will
         * be used as the data source for the image operator. */
        status = _cairo_ps_surface_emit_base85_string (surface,
                                                       mime_data,
                                                       mime_data_length,
                                                       CAIRO_PS_COMPRESS_NONE,
                                                       FALSE);
    }

    return status;
}

static cairo_status_t
_cairo_ps_surface_emit_recording_surface (cairo_ps_surface_t *surface,
                                          cairo_surface_t    *recording_surface)
{
    double old_width, old_height;
    cairo_matrix_t old_cairo_to_ps;
    cairo_content_t old_content;
    cairo_rectangle_int_t old_page_bbox;
    cairo_surface_t *free_me = NULL;
    cairo_surface_clipper_t old_clipper;
    cairo_box_t bbox;
    cairo_int_status_t status;

    old_content = surface->content;
    old_width = surface->width;
    old_height = surface->height;
    old_page_bbox = surface->page_bbox;
    old_cairo_to_ps = surface->cairo_to_ps;
    old_clipper = surface->clipper;
    _cairo_surface_clipper_init (&surface->clipper,
                                 _cairo_ps_surface_clipper_intersect_clip_path);

    if (_cairo_surface_is_snapshot (recording_surface))
        free_me = recording_surface = _cairo_surface_snapshot_get_target (recording_surface);

    status =
        _cairo_recording_surface_get_bbox ((cairo_recording_surface_t *) recording_surface,
                                           &bbox,
                                           NULL);
    if (unlikely (status))
        goto err;

#if DEBUG_PS
    _cairo_output_stream_printf (surface->stream,
                                 "%% _cairo_ps_surface_emit_recording_surface (%f, %f), (%f, %f)\n",
                                 _cairo_fixed_to_double (bbox.p1.x),
                                 _cairo_fixed_to_double (bbox.p1.y),
                                 _cairo_fixed_to_double (bbox.p2.x),
                                 _cairo_fixed_to_double (bbox.p2.y));
#endif

    surface->width = _cairo_fixed_to_double (bbox.p2.x - bbox.p1.x);
    surface->height = _cairo_fixed_to_double (bbox.p2.y - bbox.p1.y);
    _cairo_box_round_to_rectangle (&bbox, &surface->page_bbox);

    surface->current_pattern_is_solid_color = FALSE;
    _cairo_pdf_operators_reset (&surface->pdf_operators);
    cairo_matrix_init (&surface->cairo_to_ps, 1, 0, 0, -1, 0, surface->height);
    _cairo_pdf_operators_set_cairo_to_pdf_matrix (&surface->pdf_operators,
                                                  &surface->cairo_to_ps);
    _cairo_output_stream_printf (surface->stream, "  q\n");

    if (recording_surface->content == CAIRO_CONTENT_COLOR) {
        surface->content = CAIRO_CONTENT_COLOR;
        _cairo_output_stream_printf (surface->stream,
                                     "  0 g %d %d %d %d rectfill\n",
                                     surface->page_bbox.x,
                                     surface->page_bbox.y,
                                     surface->page_bbox.width,
                                     surface->page_bbox.height);
    }

    status = _cairo_recording_surface_replay_region (recording_surface,
                                                     NULL,
                                                     &surface->base,
                                                     CAIRO_RECORDING_REGION_NATIVE);
    assert (status != CAIRO_INT_STATUS_UNSUPPORTED);
    if (unlikely (status))
        goto err;

    status = _cairo_pdf_operators_flush (&surface->pdf_operators);
    if (unlikely (status))
        goto err;

    _cairo_output_stream_printf (surface->stream, "  Q\n");

    _cairo_surface_clipper_reset (&surface->clipper);
    surface->clipper = old_clipper;
    surface->content = old_content;
    surface->width = old_width;
    surface->height = old_height;
    surface->page_bbox = old_page_bbox;
    surface->current_pattern_is_solid_color = FALSE;
    _cairo_pdf_operators_reset (&surface->pdf_operators);
    surface->cairo_to_ps = old_cairo_to_ps;

    _cairo_pdf_operators_set_cairo_to_pdf_matrix (&surface->pdf_operators,
                                                  &surface->cairo_to_ps);

err:
    cairo_surface_destroy (free_me);
    return status;
}

static cairo_int_status_t
_cairo_ps_surface_emit_recording_subsurface (cairo_ps_surface_t *surface,
                                             cairo_surface_t    *recording_surface,
                                             const cairo_rectangle_int_t *extents)
{
    double old_width, old_height;
    cairo_matrix_t old_cairo_to_ps;
    cairo_content_t old_content;
    cairo_rectangle_int_t old_page_bbox;
    cairo_surface_clipper_t old_clipper;
    cairo_surface_t *free_me = NULL;
    cairo_int_status_t status;

    old_content = surface->content;
    old_width = surface->width;
    old_height = surface->height;
    old_page_bbox = surface->page_bbox;
    old_cairo_to_ps = surface->cairo_to_ps;
    old_clipper = surface->clipper;
    _cairo_surface_clipper_init (&surface->clipper,
                                 _cairo_ps_surface_clipper_intersect_clip_path);

#if DEBUG_PS
    _cairo_output_stream_printf (surface->stream,
                                 "%% _cairo_ps_surface_emit_recording_subsurface (%d, %d), (%d, %d)\n",
                                 extents->x, extents->y,
                                 extents->width, extents->height);
#endif

    surface->page_bbox.x = surface->page_bbox.y = 0;
    surface->page_bbox.width = surface->width  = extents->width;
    surface->page_bbox.height = surface->height = extents->height;

    surface->current_pattern_is_solid_color = FALSE;
    _cairo_pdf_operators_reset (&surface->pdf_operators);
    cairo_matrix_init (&surface->cairo_to_ps, 1, 0, 0, -1, 0, surface->height);
    _cairo_pdf_operators_set_cairo_to_pdf_matrix (&surface->pdf_operators,
                                                  &surface->cairo_to_ps);
    _cairo_output_stream_printf (surface->stream, "  q\n");

    if (_cairo_surface_is_snapshot (recording_surface))
        free_me = recording_surface = _cairo_surface_snapshot_get_target (recording_surface);

    if (recording_surface->content == CAIRO_CONTENT_COLOR) {
        surface->content = CAIRO_CONTENT_COLOR;
        _cairo_output_stream_printf (surface->stream,
                                     "  0 g %d %d %d %d rectfill\n",
                                     surface->page_bbox.x,
                                     surface->page_bbox.y,
                                     surface->page_bbox.width,
                                     surface->page_bbox.height);
    }

    status = _cairo_recording_surface_replay_region (recording_surface,
                                                     extents,
                                                     &surface->base,
                                                     CAIRO_RECORDING_REGION_NATIVE);
    assert (status != CAIRO_INT_STATUS_UNSUPPORTED);
    if (unlikely (status))
        goto err;

    status = _cairo_pdf_operators_flush (&surface->pdf_operators);
    if (unlikely (status))
        goto err;

    _cairo_output_stream_printf (surface->stream, "  Q\n");

    _cairo_surface_clipper_reset (&surface->clipper);
    surface->clipper = old_clipper;
    surface->content = old_content;
    surface->width = old_width;
    surface->height = old_height;
    surface->page_bbox = old_page_bbox;
    surface->current_pattern_is_solid_color = FALSE;
    _cairo_pdf_operators_reset (&surface->pdf_operators);
    surface->cairo_to_ps = old_cairo_to_ps;

    _cairo_pdf_operators_set_cairo_to_pdf_matrix (&surface->pdf_operators,
                                                  &surface->cairo_to_ps);

err:
    cairo_surface_destroy (free_me);
    return status;
}

static void
_cairo_ps_surface_flatten_transparency (cairo_ps_surface_t      *surface,
                                        const cairo_color_t     *color,
                                        double                  *red,
                                        double                  *green,
                                        double                  *blue)
{
    *red   = color->red;
    *green = color->green;
    *blue  = color->blue;

    if (! CAIRO_COLOR_IS_OPAQUE (color)) {
        *red   *= color->alpha;
        *green *= color->alpha;
        *blue  *= color->alpha;
        if (surface->content == CAIRO_CONTENT_COLOR_ALPHA) {
            double one_minus_alpha = 1. - color->alpha;
            *red   += one_minus_alpha;
            *green += one_minus_alpha;
            *blue  += one_minus_alpha;
        }
    }
}

static void
_cairo_ps_surface_emit_solid_pattern (cairo_ps_surface_t    *surface,
                                      cairo_solid_pattern_t *pattern)
{
    double red, green, blue;

    _cairo_ps_surface_flatten_transparency (surface, &pattern->color, &red, &green, &blue);

    if (color_is_gray (red, green, blue))
        _cairo_output_stream_printf (surface->stream,
                                     "%f g\n",
                                     red);
    else
        _cairo_output_stream_printf (surface->stream,
                                     "%f %f %f rg\n",
                                     red, green, blue);
}

static cairo_status_t
_cairo_ps_surface_emit_surface (cairo_ps_surface_t      *surface,
                                cairo_pattern_t         *source_pattern,
                                cairo_surface_t         *source_surface,
                                cairo_operator_t         op,
                                int                      width,
                                int                      height,
                                cairo_bool_t             stencil_mask)
{
    cairo_int_status_t status;

    if (source_pattern->type == CAIRO_PATTERN_TYPE_SURFACE &&
        source_pattern->extend != CAIRO_EXTEND_PAD)
    {
        cairo_surface_t *surf = ((cairo_surface_pattern_t *) source_pattern)->surface;

        status = _cairo_ps_surface_emit_jpeg_image (surface, surf, width, height);
        if (status != CAIRO_INT_STATUS_UNSUPPORTED)
            return status;
    }

    if (source_surface->type == CAIRO_SURFACE_TYPE_RECORDING) {
        if (source_surface->backend->type == CAIRO_SURFACE_TYPE_SUBSURFACE) {
            cairo_surface_subsurface_t *sub = (cairo_surface_subsurface_t *) source_surface;
            status = _cairo_ps_surface_emit_recording_subsurface (surface, sub->target, &sub->extents);
        } else {
            status = _cairo_ps_surface_emit_recording_surface (surface, source_surface);
        }
    } else {
        cairo_image_surface_t *image = (cairo_image_surface_t *) source_surface;

        status = _cairo_ps_surface_emit_image (surface, image,
                                               op, source_pattern->filter, stencil_mask);
    }

    return status;
}


static void
_path_fixed_init_rectangle (cairo_path_fixed_t *path,
                            cairo_rectangle_int_t *rect)
{
    cairo_status_t status;

    _cairo_path_fixed_init (path);

    status = _cairo_path_fixed_move_to (path,
                                        _cairo_fixed_from_int (rect->x),
                                        _cairo_fixed_from_int (rect->y));
    assert (status == CAIRO_STATUS_SUCCESS);
    status = _cairo_path_fixed_rel_line_to (path,
                                            _cairo_fixed_from_int (rect->width),
                                            _cairo_fixed_from_int (0));
    assert (status == CAIRO_STATUS_SUCCESS);
    status = _cairo_path_fixed_rel_line_to (path,
                                            _cairo_fixed_from_int (0),
                                            _cairo_fixed_from_int (rect->height));
    assert (status == CAIRO_STATUS_SUCCESS);
    status = _cairo_path_fixed_rel_line_to (path,
                                            _cairo_fixed_from_int (-rect->width),
                                            _cairo_fixed_from_int (0));
    assert (status == CAIRO_STATUS_SUCCESS);

    status = _cairo_path_fixed_close_path (path);
    assert (status == CAIRO_STATUS_SUCCESS);
}

static cairo_status_t
_cairo_ps_surface_paint_surface (cairo_ps_surface_t     *surface,
                                 cairo_pattern_t        *pattern,
                                 cairo_rectangle_int_t  *extents,
                                 cairo_operator_t        op,
                                 cairo_bool_t            stencil_mask)
{
    cairo_status_t status;
    int width, height;
    cairo_matrix_t cairo_p2d, ps_p2d;
    cairo_path_fixed_t path;
    double x_offset, y_offset;
    cairo_surface_t *source;
    cairo_image_surface_t *image = NULL;
    void *image_extra;

    status = _cairo_pdf_operators_flush (&surface->pdf_operators);
    if (unlikely (status))
        return status;

    status = _cairo_ps_surface_acquire_source_surface_from_pattern (surface,
                                                                    pattern,
                                                                    extents,
                                                                    &width, &height,
                                                                    &x_offset, &y_offset,
                                                                    &source,
                                                                    &image_extra);
    if (unlikely (status))
        return status;

    if (pattern->extend == CAIRO_EXTEND_PAD &&
        pattern->type == CAIRO_PATTERN_TYPE_SURFACE &&
        ((cairo_surface_pattern_t *)pattern)->surface->type == CAIRO_SURFACE_TYPE_IMAGE) {
        cairo_image_surface_t *img;

        img = (cairo_image_surface_t *) source;
        status = _cairo_ps_surface_create_padded_image_from_image (surface,
                                                                   img,
                                                                   &pattern->matrix,
                                                                   extents,
                                                                   &width, &height,
                                                                   &x_offset, &y_offset,
                                                                   &image);
        if (unlikely (status))
            goto release_source;
    }

    _path_fixed_init_rectangle (&path, extents);
    status = _cairo_pdf_operators_clip (&surface->pdf_operators,
                                        &path,
                                        CAIRO_FILL_RULE_WINDING);
    _cairo_path_fixed_fini (&path);
    if (unlikely (status))
        goto release_source;

    cairo_p2d = pattern->matrix;

    if (surface->paginated_mode == CAIRO_PAGINATED_MODE_FALLBACK) {
        double x_scale = cairo_p2d.xx;
        double y_scale = cairo_p2d.yy;

        _cairo_output_stream_printf (surface->stream,
                                     "%% Fallback Image: x=%f y=%f w=%d h=%d ",
                                     -cairo_p2d.x0/x_scale,
                                     -cairo_p2d.y0/y_scale,
                                     (int)(width/x_scale),
                                     (int)(height/y_scale));
        if (x_scale == y_scale) {
            _cairo_output_stream_printf (surface->stream,
                                         "res=%fppi ",
                                         x_scale*72);
        } else {
            _cairo_output_stream_printf (surface->stream,
                                         "res=%fx%fppi ",
                                         x_scale*72,
                                         y_scale*72);
        }
        _cairo_output_stream_printf (surface->stream,
                                     "size=%ld\n",
                                     (long)width*height*3);
    } else {
        if (op == CAIRO_OPERATOR_SOURCE) {
            _cairo_output_stream_printf (surface->stream,
                                         "%d g 0 0 %f %f rectfill\n",
                                         surface->content == CAIRO_CONTENT_COLOR ? 0 : 1,
                                         surface->width,
                                         surface->height);
        }
    }

    status = cairo_matrix_invert (&cairo_p2d);
    /* cairo_pattern_set_matrix ensures the matrix is invertible */
    assert (status == CAIRO_STATUS_SUCCESS);

    ps_p2d = surface->cairo_to_ps;
    cairo_matrix_multiply (&ps_p2d, &cairo_p2d, &ps_p2d);
    cairo_matrix_translate (&ps_p2d, x_offset, y_offset);
    cairo_matrix_translate (&ps_p2d, 0.0, height);
    cairo_matrix_scale (&ps_p2d, 1.0, -1.0);

    if (! _cairo_matrix_is_identity (&ps_p2d)) {
        _cairo_output_stream_printf (surface->stream, "[ ");
        _cairo_output_stream_print_matrix (surface->stream, &ps_p2d);
        _cairo_output_stream_printf (surface->stream, " ] concat\n");
    }

    status = _cairo_ps_surface_emit_surface (surface,
                                             pattern,
                                             image ? &image->base : source,
                                             op,
                                             width, height,
                                             stencil_mask);

  release_source:
    if (image)
        cairo_surface_destroy (&image->base);

    _cairo_ps_surface_release_source_surface_from_pattern (surface, pattern, source, image_extra);

    return status;
}

static cairo_status_t
_cairo_ps_surface_emit_surface_pattern (cairo_ps_surface_t      *surface,
                                        cairo_pattern_t         *pattern,
                                        cairo_rectangle_int_t   *extents,
                                        cairo_operator_t         op)
{
    cairo_status_t status;
    int pattern_width = 0; /* squelch bogus compiler warning */
    int pattern_height = 0; /* squelch bogus compiler warning */
    double xstep, ystep;
    cairo_matrix_t cairo_p2d, ps_p2d;
    cairo_bool_t old_use_string_datasource;
    double x_offset, y_offset;
    cairo_surface_t *source;
    cairo_image_surface_t *image = NULL;
    void *image_extra;

    cairo_p2d = pattern->matrix;
    status = cairo_matrix_invert (&cairo_p2d);
    /* cairo_pattern_set_matrix ensures the matrix is invertible */
    assert (status == CAIRO_STATUS_SUCCESS);

    status = _cairo_ps_surface_acquire_source_surface_from_pattern (surface,
                                                                    pattern,
                                                                    extents,
                                                                    &pattern_width, &pattern_height,
                                                                    &x_offset, &y_offset,
                                                                    &source,
                                                                    &image_extra);
    if (unlikely (status))
        return status;

    if (pattern->extend == CAIRO_EXTEND_PAD) {
        cairo_image_surface_t *img;

        assert (source->type == CAIRO_SURFACE_TYPE_IMAGE);
        img = (cairo_image_surface_t *) source;
        status = _cairo_ps_surface_create_padded_image_from_image (surface,
                                                                   img,
                                                                   &pattern->matrix,
                                                                   extents,
                                                                   &pattern_width, &pattern_height,
                                                                   &x_offset, &y_offset,
                                                                   &image);
        if (unlikely (status))
            goto release_source;
    }
    if (unlikely (status))
        goto release_source;

    switch (pattern->extend) {
    case CAIRO_EXTEND_PAD:
    case CAIRO_EXTEND_NONE:
    {
        /* In PS/PDF, (as far as I can tell), all patterns are
         * repeating. So we support cairo's EXTEND_NONE semantics
         * by setting the repeat step size to a size large enough
         * to guarantee that no more than a single occurrence will
         * be visible.
         *
         * First, map the surface extents into pattern space (since
         * xstep and ystep are in pattern space).  Then use an upper
         * bound on the length of the diagonal of the pattern image
         * and the surface as repeat size.  This guarantees to never
         * repeat visibly.
         */
        double x1 = 0.0, y1 = 0.0;
        double x2 = surface->width, y2 = surface->height;
        _cairo_matrix_transform_bounding_box (&pattern->matrix,
                                              &x1, &y1, &x2, &y2,
                                              NULL);

        /* Rather than computing precise bounds of the union, just
         * add the surface extents unconditionally. We only
         * required an answer that's large enough, we don't really
         * care if it's not as tight as possible.*/
        xstep = ystep = ceil ((x2 - x1) + (y2 - y1) +
                              pattern_width + pattern_height);
        break;
    }
    case CAIRO_EXTEND_REPEAT:
        xstep = pattern_width;
        ystep = pattern_height;
        break;
    case CAIRO_EXTEND_REFLECT:
        xstep = pattern_width*2;
        ystep = pattern_height*2;
        break;
        /* All the rest (if any) should have been analyzed away, so these
         * cases should be unreachable. */
    default:
        ASSERT_NOT_REACHED;
        xstep = 0;
        ystep = 0;
    }

    _cairo_output_stream_printf (surface->stream,
                                 "/CairoPattern {\n");

    old_use_string_datasource = surface->use_string_datasource;
    surface->use_string_datasource = TRUE;
    if (op == CAIRO_OPERATOR_SOURCE) {
        _cairo_output_stream_printf (surface->stream,
                                     "%d g 0 0 %f %f rectfill\n",
                                     surface->content == CAIRO_CONTENT_COLOR ? 0 : 1,
                                     xstep, ystep);
    }
    status = _cairo_ps_surface_emit_surface (surface,
                                             pattern,
                                             image ? &image->base : source,
                                             op,
                                             pattern_width, pattern_height, FALSE);
    if (unlikely (status))
        goto release_source;

    surface->use_string_datasource = old_use_string_datasource;
    _cairo_output_stream_printf (surface->stream,
                                 "} bind def\n");

    _cairo_output_stream_printf (surface->stream,
                                 "<< /PatternType 1\n"
                                 "   /PaintType 1\n"
                                 "   /TilingType 1\n");
    _cairo_output_stream_printf (surface->stream,
                                 "   /XStep %f /YStep %f\n",
                                 xstep, ystep);

    if (pattern->extend == CAIRO_EXTEND_REFLECT) {
        _cairo_output_stream_printf (surface->stream,
                                     "   /BBox [0 0 %d %d]\n"
                                     "   /PaintProc {\n"
                                     "      pop CairoPattern\n"
                                     "      [-1 0 0  1 %d 0] concat CairoPattern\n"
                                     "      [ 1 0 0 -1 0 %d] concat CairoPattern\n"
                                     "      [-1 0 0  1 %d 0] concat CairoPattern\n"
                                     "      CairoPattern\n"
                                     "   } bind\n",
                                     pattern_width*2, pattern_height*2,
                                     pattern_width*2,
                                     pattern_height*2,
                                     pattern_width*2);
    } else {
        if (op == CAIRO_OPERATOR_SOURCE) {
            _cairo_output_stream_printf (surface->stream,
                                         "   /BBox [0 0 %f %f]\n",
                                         xstep, ystep);
        } else {
            _cairo_output_stream_printf (surface->stream,
                                         "   /BBox [0 0 %d %d]\n",
                                         pattern_width, pattern_height);
        }
        _cairo_output_stream_printf (surface->stream,
                                     "   /PaintProc { pop CairoPattern }\n");
    }

    _cairo_output_stream_printf (surface->stream,
                                 ">>\n");

    cairo_p2d = pattern->matrix;
    status = cairo_matrix_invert (&cairo_p2d);
    /* cairo_pattern_set_matrix ensures the matrix is invertible */
    assert (status == CAIRO_STATUS_SUCCESS);

    cairo_matrix_init_identity (&ps_p2d);
    cairo_matrix_translate (&ps_p2d, 0.0, surface->height);
    cairo_matrix_scale (&ps_p2d, 1.0, -1.0);
    cairo_matrix_multiply (&ps_p2d, &cairo_p2d, &ps_p2d);
    cairo_matrix_translate (&ps_p2d, 0.0, pattern_height);
    cairo_matrix_scale (&ps_p2d, 1.0, -1.0);

    _cairo_output_stream_printf (surface->stream, "[ ");
    _cairo_output_stream_print_matrix (surface->stream, &ps_p2d);
    _cairo_output_stream_printf (surface->stream,
                                 " ]\n"
                                 "makepattern setpattern\n");

  release_source:
    if (image)
        cairo_surface_destroy (&image->base);

    _cairo_ps_surface_release_source_surface_from_pattern (surface, pattern, source, image_extra);

    return status;
}

typedef struct _cairo_ps_color_stop {
    double offset;
    double color[4];
} cairo_ps_color_stop_t;

static void
_cairo_ps_surface_emit_linear_colorgradient (cairo_ps_surface_t     *surface,
                                             cairo_ps_color_stop_t  *stop1,
                                             cairo_ps_color_stop_t  *stop2)
{
    _cairo_output_stream_printf (surface->stream,
                                 "   << /FunctionType 2\n"
                                 "      /Domain [ 0 1 ]\n"
                                 "      /C0 [ %f %f %f ]\n"
                                 "      /C1 [ %f %f %f ]\n"
                                 "      /N 1\n"
                                 "   >>\n",
                                 stop1->color[0],
                                 stop1->color[1],
                                 stop1->color[2],
                                 stop2->color[0],
                                 stop2->color[1],
                                 stop2->color[2]);
}

static void
_cairo_ps_surface_emit_stitched_colorgradient (cairo_ps_surface_t    *surface,
                                               unsigned int           n_stops,
                                               cairo_ps_color_stop_t  stops[])
{
    unsigned int i;

    _cairo_output_stream_printf (surface->stream,
                                 "<< /FunctionType 3\n"
                                 "   /Domain [ 0 1 ]\n"
                                 "   /Functions [\n");
    for (i = 0; i < n_stops - 1; i++)
        _cairo_ps_surface_emit_linear_colorgradient (surface, &stops[i], &stops[i+1]);

    _cairo_output_stream_printf (surface->stream, "   ]\n");

    _cairo_output_stream_printf (surface->stream, "   /Bounds [ ");
    for (i = 1; i < n_stops-1; i++)
        _cairo_output_stream_printf (surface->stream, "%f ", stops[i].offset);
    _cairo_output_stream_printf (surface->stream, "]\n");

    _cairo_output_stream_printf (surface->stream, "   /Encode [ 1 1 %d { pop 0 1 } for ]\n",
                                 n_stops - 1);

    _cairo_output_stream_printf (surface->stream, ">>\n");
}

static void
calc_gradient_color (cairo_ps_color_stop_t *new_stop,
                     cairo_ps_color_stop_t *stop1,
                     cairo_ps_color_stop_t *stop2)
{
    int i;
    double offset = stop1->offset / (stop1->offset + 1.0 - stop2->offset);

    for (i = 0; i < 4; i++)
        new_stop->color[i] = stop1->color[i] + offset*(stop2->color[i] - stop1->color[i]);
}

#define COLOR_STOP_EPSILON 1e-6

static cairo_status_t
_cairo_ps_surface_emit_pattern_stops (cairo_ps_surface_t       *surface,
                                      cairo_gradient_pattern_t *pattern)
{
    cairo_ps_color_stop_t *allstops, *stops;
    unsigned int i, n_stops;

    allstops = _cairo_malloc_ab ((pattern->n_stops + 2), sizeof (cairo_ps_color_stop_t));
    if (unlikely (allstops == NULL))
        return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    stops = &allstops[1];
    n_stops = pattern->n_stops;

    for (i = 0; i < n_stops; i++) {
        cairo_gradient_stop_t *stop = &pattern->stops[i];

        stops[i].color[0] = stop->color.red;
        stops[i].color[1] = stop->color.green;
        stops[i].color[2] = stop->color.blue;
        stops[i].color[3] = stop->color.alpha;
        stops[i].offset = pattern->stops[i].offset;
    }

    if (pattern->base.extend == CAIRO_EXTEND_REPEAT ||
        pattern->base.extend == CAIRO_EXTEND_REFLECT)
    {
        if (stops[0].offset > COLOR_STOP_EPSILON) {
            if (pattern->base.extend == CAIRO_EXTEND_REFLECT)
                memcpy (allstops, stops, sizeof (cairo_ps_color_stop_t));
            else
                calc_gradient_color (&allstops[0], &stops[0], &stops[n_stops-1]);
            stops = allstops;
            n_stops++;
        }
        stops[0].offset = 0.0;

        if (stops[n_stops-1].offset < 1.0 - COLOR_STOP_EPSILON) {
            if (pattern->base.extend == CAIRO_EXTEND_REFLECT) {
                memcpy (&stops[n_stops],
                        &stops[n_stops - 1],
                        sizeof (cairo_ps_color_stop_t));
            } else {
                calc_gradient_color (&stops[n_stops], &stops[0], &stops[n_stops-1]);
            }
            n_stops++;
        }
        stops[n_stops-1].offset = 1.0;
    }

    for (i = 0; i < n_stops; i++) {
        double red, green, blue;
        cairo_color_t color;

        _cairo_color_init_rgba (&color,
                                stops[i].color[0],
                                stops[i].color[1],
                                stops[i].color[2],
                                stops[i].color[3]);
        _cairo_ps_surface_flatten_transparency (surface, &color,
                                                &red, &green, &blue);
        stops[i].color[0] = red;
        stops[i].color[1] = green;
        stops[i].color[2] = blue;
    }

    _cairo_output_stream_printf (surface->stream,
                                 "/CairoFunction\n");
    if (stops[0].offset == stops[n_stops - 1].offset) {
        /*
         * The first and the last stops have the same offset, but we
         * don't want a function with an empty domain, because that
         * would provoke underdefined behaviour from rasterisers.
         * This can only happen with EXTEND_PAD, because EXTEND_NONE
         * is optimised into a clear pattern in cairo-gstate, and
         * REFLECT/REPEAT are always transformed to have the first
         * stop at t=0 and the last stop at t=1.  Thus we want a step
         * function going from the first color to the last one.
         *
         * This can be accomplished by stitching three functions:
         *  - a constant first color function,
         *  - a step from the first color to the last color (with empty domain)
         *  - a constant last color function
         */
        cairo_ps_color_stop_t pad_stops[4];

        assert (pattern->base.extend == CAIRO_EXTEND_PAD);

        pad_stops[0] = pad_stops[1] = stops[0];
        pad_stops[2] = pad_stops[3] = stops[n_stops - 1];

        pad_stops[0].offset = 0;
        pad_stops[3].offset = 1;

        _cairo_ps_surface_emit_stitched_colorgradient (surface, 4, pad_stops);
    } else if (n_stops == 2) {
        /* no need for stitched function */
        _cairo_ps_surface_emit_linear_colorgradient (surface, &stops[0], &stops[1]);
    } else {
        /* multiple stops: stitch. XXX possible optimization: regulary spaced
         * stops do not require stitching. XXX */
        _cairo_ps_surface_emit_stitched_colorgradient (surface, n_stops, stops);
    }
    _cairo_output_stream_printf (surface->stream,
                                 "def\n");

    free (allstops);

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_ps_surface_emit_repeating_function (cairo_ps_surface_t       *surface,
                                           cairo_gradient_pattern_t *pattern,
                                           int                       begin,
                                           int                       end)
{
    _cairo_output_stream_printf (surface->stream,
                                 "/CairoFunction\n"
                                 "<< /FunctionType 3\n"
                                 "   /Domain [ %d %d ]\n"
                                 "   /Functions [ %d {CairoFunction} repeat ]\n"
                                 "   /Bounds [ %d 1 %d {} for ]\n",
                                 begin,
                                 end,
                                 end - begin,
                                 begin + 1,
                                 end - 1);

    if (pattern->base.extend == CAIRO_EXTEND_REFLECT) {
        _cairo_output_stream_printf (surface->stream, "   /Encode [ %d 1 %d { 2 mod 0 eq {0 1} {1 0} ifelse } for ]\n",
                                     begin,
                                     end - 1);
    } else {
        _cairo_output_stream_printf (surface->stream, "   /Encode [ %d 1 %d { pop 0 1 } for ]\n",
                                     begin,
                                     end - 1);
    }

    _cairo_output_stream_printf (surface->stream, ">> def\n");

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_ps_surface_emit_gradient (cairo_ps_surface_t       *surface,
                                 cairo_gradient_pattern_t *pattern,
                                 cairo_bool_t              is_ps_pattern)
{
    cairo_matrix_t pat_to_ps;
    cairo_circle_double_t start, end;
    double domain[2];
    cairo_status_t status;

    assert (pattern->n_stops != 0);

    status = _cairo_ps_surface_emit_pattern_stops (surface, pattern);
    if (unlikely (status))
        return status;

    pat_to_ps = pattern->base.matrix;
    status = cairo_matrix_invert (&pat_to_ps);
    /* cairo_pattern_set_matrix ensures the matrix is invertible */
    assert (status == CAIRO_STATUS_SUCCESS);
    cairo_matrix_multiply (&pat_to_ps, &pat_to_ps, &surface->cairo_to_ps);

    if (pattern->base.extend == CAIRO_EXTEND_REPEAT ||
        pattern->base.extend == CAIRO_EXTEND_REFLECT)
    {
        double bounds_x1, bounds_x2, bounds_y1, bounds_y2;
        double x_scale, y_scale, tolerance;

        /* TODO: use tighter extents */
        bounds_x1 = 0;
        bounds_y1 = 0;
        bounds_x2 = surface->width;
        bounds_y2 = surface->height;
        _cairo_matrix_transform_bounding_box (&pattern->base.matrix,
                                              &bounds_x1, &bounds_y1,
                                              &bounds_x2, &bounds_y2,
                                              NULL);

        x_scale = surface->base.x_resolution / surface->base.x_fallback_resolution;
        y_scale = surface->base.y_resolution / surface->base.y_fallback_resolution;

        tolerance = fabs (_cairo_matrix_compute_determinant (&pattern->base.matrix));
        tolerance /= _cairo_matrix_transformed_circle_major_axis (&pattern->base.matrix, 1);
        tolerance *= MIN (x_scale, y_scale);

        _cairo_gradient_pattern_box_to_parameter (pattern,
                                                  bounds_x1, bounds_y1,
                                                  bounds_x2, bounds_y2,
                                                  tolerance, domain);
    } else if (pattern->stops[0].offset == pattern->stops[pattern->n_stops - 1].offset) {
        /*
         * If the first and the last stop offset are the same, then
         * the color function is a step function.
         * _cairo_ps_surface_emit_pattern_stops emits it as a stitched
         * function no matter how many stops the pattern has.  The
         * domain of the stitched function will be [0 1] in this case.
         *
         * This is done to avoid emitting degenerate gradients for
         * EXTEND_PAD patterns having a step color function.
         */
        domain[0] = 0.0;
        domain[1] = 1.0;

        assert (pattern->base.extend == CAIRO_EXTEND_PAD);
    } else {
        domain[0] = pattern->stops[0].offset;
        domain[1] = pattern->stops[pattern->n_stops - 1].offset;
    }

    /* PS requires the first and last stop to be the same as the
     * extreme coordinates. For repeating patterns this moves the
     * extreme coordinates out to the begin/end of the repeating
     * function. For non repeating patterns this may move the extreme
     * coordinates in if there are not stops at offset 0 and 1. */
    _cairo_gradient_pattern_interpolate (pattern, domain[0], &start);
    _cairo_gradient_pattern_interpolate (pattern, domain[1], &end);

    if (pattern->base.extend == CAIRO_EXTEND_REPEAT ||
        pattern->base.extend == CAIRO_EXTEND_REFLECT)
    {
        int repeat_begin, repeat_end;

        repeat_begin = floor (domain[0]);
        repeat_end = ceil (domain[1]);

        status = _cairo_ps_surface_emit_repeating_function (surface,
                                                            pattern,
                                                            repeat_begin,
                                                            repeat_end);
        if (unlikely (status))
            return status;
    } else if (pattern->n_stops <= 2) {
        /* For EXTEND_NONE and EXTEND_PAD if there are only two stops a
         * Type 2 function is used by itself without a stitching
         * function. Type 2 functions always have the domain [0 1] */
        domain[0] = 0.0;
        domain[1] = 1.0;
    }

    if (is_ps_pattern) {
        _cairo_output_stream_printf (surface->stream,
                                     "<< /PatternType 2\n"
                                     "   /Shading\n");
    }

    if (pattern->base.type == CAIRO_PATTERN_TYPE_LINEAR) {
        _cairo_output_stream_printf (surface->stream,
                                     "   << /ShadingType 2\n"
                                     "      /ColorSpace /DeviceRGB\n"
                                     "      /Coords [ %f %f %f %f ]\n",
                                     start.center.x, start.center.y,
                                     end.center.x, end.center.y);
    } else {
        _cairo_output_stream_printf (surface->stream,
                                     "   << /ShadingType 3\n"
                                     "      /ColorSpace /DeviceRGB\n"
                                     "      /Coords [ %f %f %f %f %f %f ]\n",
                                     start.center.x, start.center.y,
                                     MAX (start.radius, 0),
                                     end.center.x, end.center.y,
                                     MAX (end.radius, 0));
    }

    if (pattern->base.extend != CAIRO_EXTEND_NONE) {
        _cairo_output_stream_printf (surface->stream,
                                     "      /Extend [ true true ]\n");
    } else {
        _cairo_output_stream_printf (surface->stream,
                                     "      /Extend [ false false ]\n");
    }

    if (domain[0] == 0.0 && domain[1] == 1.0) {
        _cairo_output_stream_printf (surface->stream,
                                     "      /Function CairoFunction\n");
    } else {
        _cairo_output_stream_printf (surface->stream,
                                     "      /Function <<\n"
                                     "         /FunctionType 3\n"
                                     "         /Domain [ 0 1 ]\n"
                                     "         /Bounds [ ]\n"
                                     "         /Encode [ %f %f ]\n"
                                     "         /Functions [ CairoFunction ]\n"
                                     "      >>\n",
                                     domain[0], domain[1]);
    }

    _cairo_output_stream_printf (surface->stream,
                                 "   >>\n");

    if (is_ps_pattern) {
        _cairo_output_stream_printf (surface->stream,
                                     ">>\n"
                                     "[ ");
    _cairo_output_stream_print_matrix (surface->stream, &pat_to_ps);
    _cairo_output_stream_printf (surface->stream, " ]\n"
                                 "makepattern setpattern\n");
    } else {
        _cairo_output_stream_printf (surface->stream,
                                     "shfill\n");
    }

    return status;
}

static cairo_status_t
_cairo_ps_surface_emit_mesh_pattern (cairo_ps_surface_t     *surface,
                                     cairo_mesh_pattern_t   *pattern,
                                     cairo_bool_t            is_ps_pattern)
{
    cairo_matrix_t pat_to_ps;
    cairo_status_t status;
    cairo_pdf_shading_t shading;
    int i;

    if (_cairo_array_num_elements (&pattern->patches) == 0)
        return CAIRO_INT_STATUS_NOTHING_TO_DO;

    pat_to_ps = pattern->base.matrix;
    status = cairo_matrix_invert (&pat_to_ps);
    /* cairo_pattern_set_matrix ensures the matrix is invertible */
    assert (status == CAIRO_STATUS_SUCCESS);

    cairo_matrix_multiply (&pat_to_ps, &pat_to_ps, &surface->cairo_to_ps);

    status = _cairo_pdf_shading_init_color (&shading, pattern);
    if (unlikely (status))
        return status;

    _cairo_output_stream_printf (surface->stream,
                                 "currentfile\n"
                                 "/ASCII85Decode filter /FlateDecode filter /ReusableStreamDecode filter\n");

    status = _cairo_ps_surface_emit_base85_string (surface,
                                                   shading.data,
                                                   shading.data_length,
                                                   CAIRO_PS_COMPRESS_DEFLATE,
                                                   FALSE);
    if (status)
        return status;

    _cairo_output_stream_printf (surface->stream,
                                 "\n"
                                 "/CairoData exch def\n");

    if (is_ps_pattern) {
        _cairo_output_stream_printf (surface->stream,
                                     "<< /PatternType 2\n"
                                     "   /Shading\n");
    }

    _cairo_output_stream_printf (surface->stream,
                                 "   << /ShadingType %d\n"
                                 "      /ColorSpace /DeviceRGB\n"
                                 "      /DataSource CairoData\n"
                                 "      /BitsPerCoordinate %d\n"
                                 "      /BitsPerComponent %d\n"
                                 "      /BitsPerFlag %d\n"
                                 "      /Decode [",
                                 shading.shading_type,
                                 shading.bits_per_coordinate,
                                 shading.bits_per_component,
                                 shading.bits_per_flag);

    for (i = 0; i < shading.decode_array_length; i++)
        _cairo_output_stream_printf (surface->stream, "%f ", shading.decode_array[i]);

    _cairo_output_stream_printf (surface->stream,
                                 "]\n"
                                 "   >>\n");

    if (is_ps_pattern) {
        _cairo_output_stream_printf (surface->stream,
                                     ">>\n"
                                     "[ \n");
        _cairo_output_stream_print_matrix (surface->stream, &pat_to_ps);
        _cairo_output_stream_printf (surface->stream,
                                     " ]\n"
                                     "makepattern\n"
                                     "setpattern\n");
    } else {
        _cairo_output_stream_printf (surface->stream, "shfill\n");
    }

    _cairo_output_stream_printf (surface->stream,
                                 "currentdict /CairoData undef\n");

    _cairo_pdf_shading_fini (&shading);

    return status;
}

static cairo_status_t
_cairo_ps_surface_emit_pattern (cairo_ps_surface_t *surface,
                                const cairo_pattern_t *pattern,
                                cairo_rectangle_int_t *extents,
                                cairo_operator_t       op)
{
    cairo_status_t status;

    if (pattern->type == CAIRO_PATTERN_TYPE_SOLID) {
        cairo_solid_pattern_t *solid = (cairo_solid_pattern_t *) pattern;

        if (surface->current_pattern_is_solid_color == FALSE ||
            ! _cairo_color_equal (&surface->current_color, &solid->color))
        {
            status = _cairo_pdf_operators_flush (&surface->pdf_operators);
            if (unlikely (status))
                return status;

            _cairo_ps_surface_emit_solid_pattern (surface, (cairo_solid_pattern_t *) pattern);

            surface->current_pattern_is_solid_color = TRUE;
            surface->current_color = solid->color;
        }

        return CAIRO_STATUS_SUCCESS;
    }

    surface->current_pattern_is_solid_color = FALSE;
    status = _cairo_pdf_operators_flush (&surface->pdf_operators);
    if (unlikely (status))
            return status;

    switch (pattern->type) {
    case CAIRO_PATTERN_TYPE_SOLID:

        _cairo_ps_surface_emit_solid_pattern (surface, (cairo_solid_pattern_t *) pattern);
        break;

    case CAIRO_PATTERN_TYPE_SURFACE:
    case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
        status = _cairo_ps_surface_emit_surface_pattern (surface,
                                                         (cairo_pattern_t *)pattern,
                                                         extents,
                                                         op);
        if (unlikely (status))
            return status;
        break;

    case CAIRO_PATTERN_TYPE_LINEAR:
    case CAIRO_PATTERN_TYPE_RADIAL:
        status = _cairo_ps_surface_emit_gradient (surface,
                                                  (cairo_gradient_pattern_t *) pattern,
                                                  TRUE);
        if (unlikely (status))
            return status;
        break;

    case CAIRO_PATTERN_TYPE_MESH:
        status = _cairo_ps_surface_emit_mesh_pattern (surface,
                                                      (cairo_mesh_pattern_t *) pattern,
                                                      TRUE);
        if (unlikely (status))
            return status;
        break;
    }

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_ps_surface_paint_gradient (cairo_ps_surface_t          *surface,
                                  const cairo_pattern_t       *source,
                                  const cairo_rectangle_int_t *extents)
{
    cairo_matrix_t pat_to_ps;
    cairo_status_t status;

    pat_to_ps = source->matrix;
    status = cairo_matrix_invert (&pat_to_ps);
    /* cairo_pattern_set_matrix ensures the matrix is invertible */
    assert (status == CAIRO_STATUS_SUCCESS);
    cairo_matrix_multiply (&pat_to_ps, &pat_to_ps, &surface->cairo_to_ps);

    if (! _cairo_matrix_is_identity (&pat_to_ps)) {
        _cairo_output_stream_printf (surface->stream, "[");
        _cairo_output_stream_print_matrix (surface->stream, &pat_to_ps);
        _cairo_output_stream_printf (surface->stream, "] concat\n");
    }

    if (source->type == CAIRO_PATTERN_TYPE_MESH) {
        status = _cairo_ps_surface_emit_mesh_pattern (surface,
                                                      (cairo_mesh_pattern_t *)source,
                                                      FALSE);
        if (unlikely (status))
            return status;
    } else {
        status = _cairo_ps_surface_emit_gradient (surface,
                                                  (cairo_gradient_pattern_t *)source,
                                                  FALSE);
        if (unlikely (status))
            return status;
    }

    return status;
}

static cairo_status_t
_cairo_ps_surface_paint_pattern (cairo_ps_surface_t           *surface,
                                 const cairo_pattern_t        *source,
                                 cairo_rectangle_int_t        *extents,
                                 cairo_operator_t              op,
                                 cairo_bool_t                  stencil_mask)
{
    switch (source->type) {
    case CAIRO_PATTERN_TYPE_SURFACE:
    case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
       return _cairo_ps_surface_paint_surface (surface,
                                               (cairo_pattern_t *)source,
                                               extents,
                                               op,
                                               stencil_mask);

    case CAIRO_PATTERN_TYPE_LINEAR:
    case CAIRO_PATTERN_TYPE_RADIAL:
    case CAIRO_PATTERN_TYPE_MESH:
        return _cairo_ps_surface_paint_gradient (surface,
                                                  source,
                                                  extents);

    case CAIRO_PATTERN_TYPE_SOLID:
    default:
       ASSERT_NOT_REACHED;
       return CAIRO_STATUS_SUCCESS;
    }
}

static cairo_bool_t
_can_paint_pattern (const cairo_pattern_t *pattern)
{
    switch (pattern->type) {
    case CAIRO_PATTERN_TYPE_SOLID:
        return FALSE;

    case CAIRO_PATTERN_TYPE_SURFACE:
    case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
        return (pattern->extend == CAIRO_EXTEND_NONE ||
                pattern->extend == CAIRO_EXTEND_PAD);

    case CAIRO_PATTERN_TYPE_LINEAR:
    case CAIRO_PATTERN_TYPE_RADIAL:
    case CAIRO_PATTERN_TYPE_MESH:
        return TRUE;

    default:
        ASSERT_NOT_REACHED;
        return FALSE;
    }
}

static cairo_bool_t
_cairo_ps_surface_get_extents (void                    *abstract_surface,
                               cairo_rectangle_int_t   *rectangle)
{
    cairo_ps_surface_t *surface = abstract_surface;

    rectangle->x = 0;
    rectangle->y = 0;

    /* XXX: The conversion to integers here is pretty bogus, (not to
     * mention the aribitray limitation of width to a short(!). We
     * may need to come up with a better interface for get_extents.
     */
    rectangle->width  = ceil (surface->width);
    rectangle->height = ceil (surface->height);

    return TRUE;
}

static void
_cairo_ps_surface_get_font_options (void                  *abstract_surface,
                                    cairo_font_options_t  *options)
{
    _cairo_font_options_init_default (options);

    cairo_font_options_set_hint_style (options, CAIRO_HINT_STYLE_NONE);
    cairo_font_options_set_hint_metrics (options, CAIRO_HINT_METRICS_OFF);
    cairo_font_options_set_antialias (options, CAIRO_ANTIALIAS_GRAY);
    _cairo_font_options_set_round_glyph_positions (options, CAIRO_ROUND_GLYPH_POS_OFF);
}

static cairo_int_status_t
_cairo_ps_surface_set_clip (cairo_ps_surface_t *surface,
                            cairo_composite_rectangles_t *composite)
{
    cairo_clip_t *clip = composite->clip;

    if (_cairo_composite_rectangles_can_reduce_clip (composite, clip))
        clip = NULL;

    if (clip == NULL) {
        if (_cairo_composite_rectangles_can_reduce_clip (composite,
                                                         surface->clipper.clip))
            return CAIRO_STATUS_SUCCESS;
    }

    return _cairo_surface_clipper_set_clip (&surface->clipper, clip);
}

static cairo_int_status_t
_cairo_ps_surface_paint (void                   *abstract_surface,
                         cairo_operator_t        op,
                         const cairo_pattern_t  *source,
                         const cairo_clip_t     *clip)
{
    cairo_ps_surface_t *surface = abstract_surface;
    cairo_output_stream_t *stream = surface->stream;
    cairo_composite_rectangles_t extents;
    cairo_status_t status;

    status = _cairo_composite_rectangles_init_for_paint (&extents,
                                                         &surface->base,
                                                         op, source, clip);
    if (unlikely (status))
        return status;

    if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) {
        status = _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded);
        goto cleanup_composite;
    }

    assert (_cairo_ps_surface_operation_supported (surface, op, source, NULL, &extents.bounded));

#if DEBUG_PS
    _cairo_output_stream_printf (stream,
                                 "%% _cairo_ps_surface_paint\n");
#endif

    status = _cairo_ps_surface_set_clip (surface, &extents);
    if (unlikely (status))
        goto cleanup_composite;

    if (_can_paint_pattern (source)) {
        status = _cairo_pdf_operators_flush (&surface->pdf_operators);
        if (unlikely (status))
            goto cleanup_composite;

        _cairo_output_stream_printf (stream, "q\n");
        status = _cairo_ps_surface_paint_pattern (surface,
                                                  source,
                                                  &extents.bounded, op, FALSE);
        if (unlikely (status))
            goto cleanup_composite;

        _cairo_output_stream_printf (stream, "Q\n");
    } else {
        status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op);
        if (unlikely (status))
            goto cleanup_composite;

        _cairo_output_stream_printf (stream, "0 0 %f %f rectfill\n",
                                     surface->width, surface->height);
    }

cleanup_composite:
    _cairo_composite_rectangles_fini (&extents);
    return status;
}

static cairo_int_status_t
_cairo_ps_surface_mask (void                    *abstract_surface,
                        cairo_operator_t         op,
                        const cairo_pattern_t   *source,
                        const cairo_pattern_t   *mask,
                        const cairo_clip_t      *clip)
{
    cairo_ps_surface_t *surface = abstract_surface;
    cairo_output_stream_t *stream = surface->stream;
    cairo_composite_rectangles_t extents;
    cairo_status_t status;

    status = _cairo_composite_rectangles_init_for_mask (&extents,
                                                        &surface->base,
                                                        op, source, mask, clip);
    if (unlikely (status))
        return status;

    if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) {
        status = _cairo_ps_surface_analyze_operation (surface, op, source, mask, &extents.bounded);
        goto cleanup_composite;
    }

    assert (_cairo_ps_surface_operation_supported (surface, op, source, mask, &extents.bounded));

#if DEBUG_PS
    _cairo_output_stream_printf (stream,
                                 "%% _cairo_ps_surface_mask\n");
#endif

    status = _cairo_ps_surface_set_clip (surface, &extents);
    if (unlikely (status))
        goto cleanup_composite;

    status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op);
    if (unlikely (status))
        goto cleanup_composite;

    _cairo_output_stream_printf (stream, "q\n");
    status = _cairo_ps_surface_paint_pattern (surface,
                                              mask,
                                              &extents.bounded, op, TRUE);
    if (unlikely (status))
        goto cleanup_composite;

    _cairo_output_stream_printf (stream, "Q\n");

cleanup_composite:
    _cairo_composite_rectangles_fini (&extents);
    return status;
}

static cairo_int_status_t
_cairo_ps_surface_stroke (void                  *abstract_surface,
                          cairo_operator_t       op,
                          const cairo_pattern_t *source,
                          const cairo_path_fixed_t      *path,
                          const cairo_stroke_style_t    *style,
                          const cairo_matrix_t  *ctm,
                          const cairo_matrix_t  *ctm_inverse,
                          double                 tolerance,
                          cairo_antialias_t      antialias,
                          const cairo_clip_t            *clip)
{
    cairo_ps_surface_t *surface = abstract_surface;
    cairo_composite_rectangles_t extents;
    cairo_int_status_t status;

    status = _cairo_composite_rectangles_init_for_stroke (&extents,
                                                          &surface->base,
                                                          op, source,
                                                          path, style, ctm,
                                                          clip);
    if (unlikely (status))
        return status;

    /* use the more accurate extents */
    {
        cairo_rectangle_int_t r;
        cairo_box_t b;

        status = _cairo_path_fixed_stroke_extents (path, style,
                                                   ctm, ctm_inverse,
                                                   tolerance,
                                                   &r);
        if (unlikely (status))
            goto cleanup_composite;

        _cairo_box_from_rectangle (&b, &r);
        status = _cairo_composite_rectangles_intersect_mask_extents (&extents, &b);
        if (unlikely (status))
            goto cleanup_composite;
    }

    if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) {
        status = _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded);
        goto cleanup_composite;
    }

    assert (_cairo_ps_surface_operation_supported (surface, op, source, NULL, &extents.bounded));

#if DEBUG_PS
    _cairo_output_stream_printf (surface->stream,
                                 "%% _cairo_ps_surface_stroke\n");
#endif

    status = _cairo_ps_surface_set_clip (surface, &extents);
    if (unlikely (status))
        goto cleanup_composite;

    status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op);
    if (unlikely (status))
        goto cleanup_composite;

    status = _cairo_pdf_operators_stroke (&surface->pdf_operators,
                                          path,
                                          style,
                                          ctm,
                                          ctm_inverse);

cleanup_composite:
    _cairo_composite_rectangles_fini (&extents);
    return status;
}

static cairo_int_status_t
_cairo_ps_surface_fill (void            *abstract_surface,
                        cairo_operator_t         op,
                        const cairo_pattern_t   *source,
                        const cairo_path_fixed_t*path,
                        cairo_fill_rule_t        fill_rule,
                        double                   tolerance,
                        cairo_antialias_t        antialias,
                        const cairo_clip_t              *clip)
{
    cairo_ps_surface_t *surface = abstract_surface;
    cairo_composite_rectangles_t extents;
    cairo_int_status_t status;

    status = _cairo_composite_rectangles_init_for_fill (&extents,
                                                        &surface->base,
                                                        op, source, path,
                                                        clip);
    if (unlikely (status))
        return status;

    /* use the more accurate extents */
    {
        cairo_rectangle_int_t r;
        cairo_box_t b;

        _cairo_path_fixed_fill_extents (path,
                                        fill_rule,
                                        tolerance,
                                        &r);

        _cairo_box_from_rectangle (&b, &r);
        status = _cairo_composite_rectangles_intersect_mask_extents (&extents, &b);
        if (unlikely (status))
            goto cleanup_composite;
    }

    if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) {
        status = _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded);
        goto cleanup_composite;
    }

    assert (_cairo_ps_surface_operation_supported (surface, op, source, NULL, &extents.bounded));

#if DEBUG_PS
    _cairo_output_stream_printf (surface->stream,
                                 "%% _cairo_ps_surface_fill\n");
#endif

    status = _cairo_pdf_operators_flush (&surface->pdf_operators);
    if (unlikely (status))
        goto cleanup_composite;

    status = _cairo_ps_surface_set_clip (surface, &extents);
    if (unlikely (status))
        goto cleanup_composite;

    if (_can_paint_pattern (source)) {
        _cairo_output_stream_printf (surface->stream, "q\n");

        status =  _cairo_pdf_operators_clip (&surface->pdf_operators,
                                             path,
                                             fill_rule);
        if (unlikely (status))
            goto cleanup_composite;

        status = _cairo_ps_surface_paint_pattern (surface,
                                                  source,
                                                  &extents.bounded, op, FALSE);
        if (unlikely (status))
            goto cleanup_composite;

        _cairo_output_stream_printf (surface->stream, "Q\n");
        _cairo_pdf_operators_reset (&surface->pdf_operators);
    } else {
        status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op);
        if (unlikely (status))
            goto cleanup_composite;

        status = _cairo_pdf_operators_fill (&surface->pdf_operators,
                                            path,
                                            fill_rule);
    }

cleanup_composite:
    _cairo_composite_rectangles_fini (&extents);
    return status;
}

static cairo_bool_t
_cairo_ps_surface_has_show_text_glyphs  (void                   *abstract_surface)
{
    return TRUE;
}

static cairo_int_status_t
_cairo_ps_surface_show_text_glyphs (void                       *abstract_surface,
                                    cairo_operator_t            op,
                                    const cairo_pattern_t      *source,
                                    const char                 *utf8,
                                    int                         utf8_len,
                                    cairo_glyph_t              *glyphs,
                                    int                         num_glyphs,
                                    const cairo_text_cluster_t *clusters,
                                    int                         num_clusters,
                                    cairo_text_cluster_flags_t  cluster_flags,
                                    cairo_scaled_font_t        *scaled_font,
                                    const cairo_clip_t         *clip)
{
    cairo_ps_surface_t *surface = abstract_surface;
    cairo_composite_rectangles_t extents;
    cairo_bool_t overlap;
    cairo_status_t status;

    status = _cairo_composite_rectangles_init_for_glyphs (&extents,
                                                          &surface->base,
                                                          op, source,
                                                          scaled_font,
                                                          glyphs, num_glyphs,
                                                          clip,
                                                          &overlap);
    if (unlikely (status))
        return status;

    if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) {
        status = _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded);
        goto cleanup_composite;
    }

    assert (_cairo_ps_surface_operation_supported (surface, op, source, NULL, &extents.bounded));

#if DEBUG_PS
    _cairo_output_stream_printf (surface->stream,
                                 "%% _cairo_ps_surface_show_glyphs\n");
#endif

    status = _cairo_ps_surface_set_clip (surface, &extents);
    if (unlikely (status))
        goto cleanup_composite;

    status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op);
    if (unlikely (status))
        goto cleanup_composite;

    status = _cairo_pdf_operators_show_text_glyphs (&surface->pdf_operators,
                                                    utf8, utf8_len,
                                                    glyphs, num_glyphs,
                                                    clusters, num_clusters,
                                                    cluster_flags,
                                                    scaled_font);

cleanup_composite:
    _cairo_composite_rectangles_fini (&extents);
    return status;
}

static const char **
_cairo_ps_surface_get_supported_mime_types (void                 *abstract_surface)
{
    return _cairo_ps_supported_mime_types;
}

static void
_cairo_ps_surface_set_paginated_mode (void                      *abstract_surface,
                                      cairo_paginated_mode_t     paginated_mode)
{
    cairo_ps_surface_t *surface = abstract_surface;
    cairo_status_t status;

    surface->paginated_mode = paginated_mode;

    if (surface->clipper.clip != NULL) {
        status = _cairo_pdf_operators_flush (&surface->pdf_operators);

        _cairo_output_stream_printf (surface->stream, "Q q\n");
        _cairo_surface_clipper_reset (&surface->clipper);
    }
}

static cairo_int_status_t
_cairo_ps_surface_set_bounding_box (void                *abstract_surface,
                                    cairo_box_t         *bbox)
{
    cairo_ps_surface_t *surface = abstract_surface;
    int i, num_comments;
    char **comments;
    int x1, y1, x2, y2;
    cairo_bool_t has_page_media, has_page_bbox;
    const char *page_media;

    x1 = floor (_cairo_fixed_to_double (bbox->p1.x));
    y1 = floor (surface->height - _cairo_fixed_to_double (bbox->p2.y));
    x2 = ceil (_cairo_fixed_to_double (bbox->p2.x));
    y2 = ceil (surface->height - _cairo_fixed_to_double (bbox->p1.y));

    surface->page_bbox.x = x1;
    surface->page_bbox.y = y1;
    surface->page_bbox.width  = x2 - x1;
    surface->page_bbox.height = y2 - y1;

    _cairo_output_stream_printf (surface->stream,
                                 "%%%%Page: %d %d\n",
                                 surface->num_pages,
                                 surface->num_pages);

    _cairo_output_stream_printf (surface->stream,
                                 "%%%%BeginPageSetup\n");

    has_page_media = FALSE;
    has_page_bbox = FALSE;
    num_comments = _cairo_array_num_elements (&surface->dsc_page_setup_comments);
    comments = _cairo_array_index (&surface->dsc_page_setup_comments, 0);
    for (i = 0; i < num_comments; i++) {
        _cairo_output_stream_printf (surface->stream,
                                     "%s\n", comments[i]);
        if (strncmp (comments[i], "%%PageMedia:", 11) == 0)
            has_page_media = TRUE;

        if (strncmp (comments[i], "%%PageBoundingBox:", 18) == 0)
            has_page_bbox = TRUE;

        free (comments[i]);
        comments[i] = NULL;
    }
    _cairo_array_truncate (&surface->dsc_page_setup_comments, 0);

    if (!has_page_media && !surface->eps) {
        page_media = _cairo_ps_surface_get_page_media (surface);
        if (unlikely (page_media == NULL))
            return _cairo_error (CAIRO_STATUS_NO_MEMORY);

        _cairo_output_stream_printf (surface->stream,
                                     "%%%%PageMedia: %s\n",
                                     page_media);
    }

    if (!has_page_bbox) {
        _cairo_output_stream_printf (surface->stream,
                                     "%%%%PageBoundingBox: %d %d %d %d\n",
                                     x1, y1, x2, y2);
    }

    if (!surface->eps) {
        _cairo_output_stream_printf (surface->stream,
                                     "%f %f cairo_set_page_size\n",
                                     ceil(surface->width),
                                     ceil(surface->height));
    }

    _cairo_output_stream_printf (surface->stream,
                                 "%%%%EndPageSetup\n"
                                 "q %d %d %d %d rectclip q\n",
                                 surface->page_bbox.x,
                                 surface->page_bbox.y,
                                 surface->page_bbox.width,
                                 surface->page_bbox.height);

    if (surface->num_pages == 1) {
        surface->bbox_x1 = x1;
        surface->bbox_y1 = y1;
        surface->bbox_x2 = x2;
        surface->bbox_y2 = y2;
    } else {
        if (x1 < surface->bbox_x1)
            surface->bbox_x1 = x1;
        if (y1 < surface->bbox_y1)
            surface->bbox_y1 = y1;
        if (x2 > surface->bbox_x2)
            surface->bbox_x2 = x2;
        if (y2 > surface->bbox_y2)
            surface->bbox_y2 = y2;
    }
    surface->current_pattern_is_solid_color = FALSE;
    _cairo_pdf_operators_reset (&surface->pdf_operators);

    return _cairo_output_stream_get_status (surface->stream);
}

static cairo_bool_t
_cairo_ps_surface_supports_fine_grained_fallbacks (void     *abstract_surface)
{
    return TRUE;
}

static const cairo_surface_backend_t cairo_ps_surface_backend = {
    CAIRO_SURFACE_TYPE_PS,
    _cairo_ps_surface_finish,

    _cairo_default_context_create,

    NULL, /* create similar: handled by wrapper */
    NULL, /* create similar image */
    NULL, /* map to image */
    NULL, /* unmap image */

    _cairo_surface_default_source,
    NULL, /* acquire_source_image */
    NULL, /* release_source_image */
    NULL, /* snapshot */

    NULL, /* cairo_ps_surface_copy_page */
    _cairo_ps_surface_show_page,

    _cairo_ps_surface_get_extents,
    _cairo_ps_surface_get_font_options,

    NULL, /* flush */
    NULL, /* mark_dirty_rectangle */

    /* Here are the drawing functions */

    _cairo_ps_surface_paint, /* paint */
    _cairo_ps_surface_mask,
    _cairo_ps_surface_stroke,
    _cairo_ps_surface_fill,
    NULL, /* fill-stroke */
    NULL, /* show_glyphs */
    _cairo_ps_surface_has_show_text_glyphs,
    _cairo_ps_surface_show_text_glyphs,
    _cairo_ps_surface_get_supported_mime_types,
};

static const cairo_paginated_surface_backend_t cairo_ps_surface_paginated_backend = {
    _cairo_ps_surface_start_page,
    _cairo_ps_surface_set_paginated_mode,
    _cairo_ps_surface_set_bounding_box,
    NULL, /* _cairo_ps_surface_has_fallback_images, */
    _cairo_ps_surface_supports_fine_grained_fallbacks,
};