/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c

Bug Summary

File:	root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c
Warning:	line 1802, column 12 Dereference of null pointer (loaded from variable 'y_offset')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -O2 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name cairo-pdf-surface.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/gfx/cairo/cairo/src -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/gfx/cairo/cairo/src -resource-dir /usr/lib/llvm-23/lib/clang/23 -include /root/firefox-clang/config/gcc_hidden.h -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG=1 -D HAVE_FT_LOAD_SFNT_TABLE -D PACKAGE_VERSION="moz" -D PACKAGE_BUGREPORT="http://bugzilla.mozilla.org/" -D CAIRO_HAS_PTHREAD -D _GNU_SOURCE -D MOZ_TREE_PIXMAN -D SIZEOF_VOID_P=__SIZEOF_POINTER__ -D SIZEOF_INT=__SIZEOF_INT__ -D SIZEOF_LONG=__SIZEOF_LONG__ -D SIZEOF_LONG_LONG=__SIZEOF_LONG_LONG__ -D HAVE_UINT64_T -D HAVE_CXX11_ATOMIC_PRIMITIVES -D MOZ_HAS_MOZGLUE -D MOZILLA_INTERNAL_API -D IMPL_LIBXUL -D MOZ_SUPPORT_LEAKCHECKING -D STATIC_EXPORTABLE_JS_API -I /root/firefox-clang/gfx/cairo/cairo/src -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/gfx/cairo/cairo/src -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/freetype2 -I /usr/include/libpng16 -internal-isystem /usr/lib/llvm-23/lib/clang/23/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-error=tautological-type-limit-compare -Wno-range-loop-analysis -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-unknown-warning-option -Wno-character-conversion -Wno-enum-compare -Wno-int-to-pointer-cast -Wno-int-conversion -Wno-incompatible-pointer-types -Wno-sign-compare -Wno-type-limits -Wno-missing-field-initializers -Wno-conversion -Wno-narrowing -Wno-switch -Wno-unused -Wno-unused-variable -Wno-error=uninitialized -Wno-absolute-value -Wno-deprecated-register -Wno-incompatible-pointer-types -Wno-macro-redefined -Wno-shift-negative-value -Wno-tautological-compare -Wno-tautological-constant-out-of-range-compare -Wno-unreachable-code -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fdiagnostics-absolute-paths -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -mllvm -dwarf-linkage-names=Abstract -faddrsig -fdwarf2-cfi-asm -o /tmp/scan-build-2026-09-01-224014-2642839-1 -x c /root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c
1/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */
2/* cairo - a vector graphics library with display and print output
*
* Copyright © 2004 Red Hat, Inc
* Copyright © 2006 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):
*	Kristian Høgsberg <krh@redhat.com>
*	Carl Worth <cworth@cworth.org>
*	Adrian Johnson <ajohnson@redneon.com>
*/

42#define _DEFAULT_SOURCE1 /* for snprintf() */
43#include "cairoint.h"

45#include "cairo-pdf.h"
46#include "cairo-pdf-surface-private.h"
47#include "cairo-pdf-operators-private.h"
48#include "cairo-pdf-shading-private.h"

50#include "cairo-array-private.h"
51#include "cairo-analysis-surface-private.h"
52#include "cairo-composite-rectangles-private.h"
53#include "cairo-default-context-private.h"
54#include "cairo-error-private.h"
55#include "cairo-user-font-private.h"
56#include "cairo-image-surface-inline.h"
57#include "cairo-image-info-private.h"
58#include "cairo-recording-surface-inline.h"
59#include "cairo-recording-surface-private.h"
60#include "cairo-output-stream-private.h"
61#include "cairo-paginated-private.h"
62#include "cairo-scaled-font-subsets-private.h"
63#include "cairo-surface-clipper-private.h"
64#include "cairo-surface-snapshot-inline.h"
65#include "cairo-surface-subsurface-private.h"
66#include "cairo-type3-glyph-surface-private.h"

68#include <zlib.h>

70/*
* Page Structure of the Generated PDF:
*
* Each page requiring fallbacks images contains a knockout group at
* the top level. The first operation of the knockout group paints a
* group containing all the supported drawing operations. Fallback
* images (if any) are painted in the knockout group. This ensures
* that fallback images do not composite with any content under the
* fallback images.
*
* Streams:
*
* This PDF surface has three types of streams:
*  - PDF Stream
*  - Content Stream
*  - Group Stream
*  - Object stream
*
* Calling _cairo_output_stream_printf (surface->output, ...) will
* write to the currently open stream.
*
* PDF Stream:
*   A PDF Stream may be opened and closed with the following functions:
*     _cairo_pdf_surface_open stream ()
*     _cairo_pdf_surface_close_stream ()
*
*   PDF Streams are written directly to the PDF file. They are used for
*   fonts, images and patterns.
*
* Content Stream:
*   The Content Stream is opened and closed with the following functions:
*     _cairo_pdf_surface_open_content_stream ()
*     _cairo_pdf_surface_close_content_stream ()
*
*   The Content Stream contains the text and graphics operators.
*
* Group Stream:
*   A Group Stream may be opened and closed with the following functions:
*     _cairo_pdf_surface_open_group ()
*     _cairo_pdf_surface_close_group ()
*
*   A Group Stream is a Form XObject. It is used for short sequences
*   of operators. As the content is very short the group is stored in
*   memory until it is closed. This allows some optimization such as
*   including the Resource dictionary and stream length inside the
*   XObject instead of using an indirect object.
*
* Object Stream (PDF 1.5)
*   An Object Stream may be opened and closed with the following functions:
*     _cairo_pdf_surface_open_object_stream ()
*     _cairo_pdf_surface_close_object_stream ()
*
*  An Object Stream contains one or more objects compressed into a stream.
*  Only non stream objects are permitted. When emitting objects intended for
*  the Object Stream, enclose the emit object operation with
*  _cairo_pdf_surface_object_begin()/_cairo_pdf_surface_object_end().
*/

128/**
* SECTION:cairo-pdf
* @Title: PDF Surfaces
* @Short_Description: Rendering PDF documents
* @See_Also: #cairo_surface_t
*
* The PDF surface is used to render cairo graphics to Adobe
* PDF files and is a multi-page vector surface backend.
*
* The following mime types are supported on source patterns:
* %CAIRO_MIME_TYPE_JPEG, %CAIRO_MIME_TYPE_JP2,
* %CAIRO_MIME_TYPE_UNIQUE_ID, %CAIRO_MIME_TYPE_JBIG2,
* %CAIRO_MIME_TYPE_JBIG2_GLOBAL, %CAIRO_MIME_TYPE_JBIG2_GLOBAL_ID,
* %CAIRO_MIME_TYPE_CCITT_FAX, %CAIRO_MIME_TYPE_CCITT_FAX_PARAMS.
*
* # JBIG2 Images #
* JBIG2 data in PDF must be in the embedded format as described in
* ISO/IEC 11544. Image specific JBIG2 data must be in
* %CAIRO_MIME_TYPE_JBIG2.  Any global segments in the JBIG2 data
* (segments with page association field set to 0) must be in
* %CAIRO_MIME_TYPE_JBIG2_GLOBAL. The global data may be shared by
* multiple images. All images sharing the same global data must set
* %CAIRO_MIME_TYPE_JBIG2_GLOBAL_ID to a unique identifier. At least
* one of the images must provide the global data using
* %CAIRO_MIME_TYPE_JBIG2_GLOBAL. The global data will only be
* embedded once and shared by all JBIG2 images with the same
* %CAIRO_MIME_TYPE_JBIG2_GLOBAL_ID.
*
* # CCITT Fax Images # {#ccitt}
* The %CAIRO_MIME_TYPE_CCITT_FAX mime data requires a number of decoding
* parameters These parameters are specified using %CAIRO_MIME_TYPE_CCITT_FAX_PARAMS.
*
* %CAIRO_MIME_TYPE_CCITT_FAX_PARAMS mime data must contain a string of the form
* "param1=value1 param2=value2 ...".
*
* @Columns: [required] An integer specifying the width of the image in pixels.
*
* @Rows: [required] An integer specifying the height of the image in scan lines.
*
* @K: [optional] An integer identifying the encoding scheme used. < 0
* is 2 dimensional Group 4, = 0 is Group3 1 dimensional, > 0 is mixed 1
* and 2 dimensional encoding. Default is 0.
*
* @EndOfLine: [optional] If true end-of-line bit patterns are present. Default is false.
*
* @EncodedByteAlign: [optional] If true the end of line is padded
* with 0 bits so the next line begins on a byte boundary. Default is false.
*
* @EndOfBlock: [optional] If true the data contains an end-of-block pattern. Default is true.
*
* @BlackIs1: [optional] If true 1 bits are black pixels. Default is false.
*
* @DamagedRowsBeforeError: [optional] An integer specifying the
* number of damages rows tolerated before an error occurs. Default is 0.
*
* Boolean values may be "true" or "false", or 1 or 0.
*
* These parameters are the same as the CCITTFaxDecode parameters in the
* [PostScript Language Reference](https://www.adobe.com/products/postscript/pdfs/PLRM.pdf)
* and [Portable Document Format (PDF)](https://www.adobe.com/content/dam/Adobe/en/devnet/pdf/pdfs/PDF32000_2008.pdf).
* Refer to these documents for further details.
*
* An example %CAIRO_MIME_TYPE_CCITT_FAX_PARAMS string is:
*
* <programlisting>
* "Columns=10230 Rows=40000 K=1 EndOfLine=true EncodedByteAlign=1 BlackIs1=false"
* </programlisting>
*
**/

198static cairo_bool_t
199_cairo_pdf_surface_get_extents (void		        *abstract_surface,
		cairo_rectangle_int_t   *rectangle);

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

211static const cairo_pdf_version_t _cairo_pdf_versions[] =
212{
  CAIRO_PDF_VERSION_1_4,
  CAIRO_PDF_VERSION_1_5,
  CAIRO_PDF_VERSION_1_6,
  CAIRO_PDF_VERSION_1_7
217};

219#define CAIRO_PDF_VERSION_LAST((int) (sizeof (_cairo_pdf_versions) / sizeof (_cairo_pdf_versions
[0]))) ARRAY_LENGTH (_cairo_pdf_versions)((int) (sizeof (_cairo_pdf_versions) / sizeof (_cairo_pdf_versions
[0])))

221static const char * _cairo_pdf_version_strings[CAIRO_PDF_VERSION_LAST((int) (sizeof (_cairo_pdf_versions) / sizeof (_cairo_pdf_versions
[0])))] =
222{
  "PDF 1.4",
  "PDF 1.5",
  "PDF 1.6",
  "PDF 1.7"
227};

229static const char *_cairo_pdf_supported_mime_types[] =
230{
  CAIRO_MIME_TYPE_JPEG"image/jpeg",
  CAIRO_MIME_TYPE_JP2"image/jp2",
  CAIRO_MIME_TYPE_UNIQUE_ID"application/x-cairo.uuid",
  CAIRO_MIME_TYPE_JBIG2"application/x-cairo.jbig2",
  CAIRO_MIME_TYPE_JBIG2_GLOBAL"application/x-cairo.jbig2-global",
  CAIRO_MIME_TYPE_JBIG2_GLOBAL_ID"application/x-cairo.jbig2-global-id",
  CAIRO_MIME_TYPE_CCITT_FAX"image/g3fax",
  CAIRO_MIME_TYPE_CCITT_FAX_PARAMS"application/x-cairo.ccitt.params",
  NULL((void*)0)
240};

242/* PDF cross-reference stream types */
243typedef enum {
  PDF_OBJECT_FREE = 0,
  PDF_OBJECT_UNCOMPRESSED = 1,
  PDF_OBJECT_COMPRESSED = 2,
247} cairo_pdf_object_type_t;

249typedef struct _cairo_pdf_object {
  cairo_pdf_object_type_t type;
  union {
long long offset; /* type == PDF_OBJECT_UNCOMPRESSED */
struct compressed_obj {  /* type == PDF_OBJECT_COMPRESSED */
   cairo_pdf_resource_t xref_stream;
   int index;
} compressed_obj;
  } u;
258} cairo_pdf_object_t;

260typedef struct _cairo_xref_stream_object {
  cairo_pdf_resource_t resource;
  long long offset;
263} cairo_xref_stream_object_t;

265typedef struct _cairo_pdf_font {
  unsigned int font_id;
  unsigned int subset_id;
  cairo_pdf_resource_t subset_resource;
269} cairo_pdf_font_t;

271typedef struct _cairo_pdf_rgb_linear_function {
  cairo_pdf_resource_t resource;
  double               color1[3];
  double               color2[3];
275} cairo_pdf_rgb_linear_function_t;

277typedef struct _cairo_pdf_alpha_linear_function {
  cairo_pdf_resource_t resource;
  double               alpha1;
  double               alpha2;
281} cairo_pdf_alpha_linear_function_t;

283static void
284_cairo_pdf_surface_clear (cairo_pdf_surface_t *surface,
	  cairo_bool_t         clear_doc_surfaces);

287static void
288_cairo_pdf_smask_group_destroy (cairo_pdf_smask_group_t *group);

290static cairo_int_status_t
291_cairo_pdf_surface_add_font (unsigned int        font_id,
	     unsigned int        subset_id,
	     void		*closure);

295static void
296_cairo_pdf_group_resources_init (cairo_pdf_group_resources_t *res);

298static cairo_int_status_t
299_cairo_pdf_surface_open_stream (cairo_pdf_surface_t	*surface,
		cairo_pdf_resource_t    *resource,
                              cairo_bool_t             compressed,
		const char		*fmt,
		...) CAIRO_PRINTF_FORMAT(4, 5)__attribute__((__format__(__printf__, 4, 5)));
304static cairo_int_status_t
305_cairo_pdf_surface_close_stream (cairo_pdf_surface_t	*surface);

307static cairo_int_status_t
308_cairo_pdf_surface_emit_surface (cairo_pdf_surface_t        *surface,
		 cairo_pdf_source_surface_t *source,
		 cairo_bool_t                test,
		 cairo_bool_t               *is_image);

313static cairo_int_status_t
314_cairo_pdf_surface_write_page (cairo_pdf_surface_t *surface);

316static cairo_int_status_t
317_cairo_pdf_surface_write_pages (cairo_pdf_surface_t *surface);

319static cairo_int_status_t
320_cairo_pdf_surface_write_catalog (cairo_pdf_surface_t *surface,
		  cairo_pdf_resource_t catalog);

323static long long
324_cairo_pdf_surface_write_xref (cairo_pdf_surface_t *surface);

326static cairo_int_status_t
327_cairo_pdf_surface_write_xref_stream (cairo_pdf_surface_t  *surface,
		      cairo_pdf_resource_t  xref_res,
		      cairo_pdf_resource_t  root_res,
		      cairo_pdf_resource_t  info_res,
		      long long            *xref_offset);

333static cairo_int_status_t
334_cairo_pdf_surface_write_patterns_and_smask_groups (cairo_pdf_surface_t *surface,
				    cairo_bool_t         finish);

337static cairo_int_status_t
338_cairo_pdf_surface_emit_font_subsets (cairo_pdf_surface_t *surface);

340static cairo_bool_t
341_cairo_pdf_source_surface_equal (const void *key_a, const void *key_b);

343static cairo_bool_t
344_cairo_pdf_color_glyph_equal (const void *key_a, const void *key_b);

346static const cairo_surface_backend_t cairo_pdf_surface_backend;
347static const cairo_paginated_surface_backend_t cairo_pdf_surface_paginated_backend;

349cairo_pdf_resource_t
350_cairo_pdf_surface_new_object (cairo_pdf_surface_t *surface)
351{
  cairo_pdf_resource_t resource;
  cairo_int_status_t status;
  cairo_pdf_object_t object;

  /* Default to Uncompressed. If this object is used with
   * _cairo_pdf_surface_object_begin() and Object Streams are
   * enabled it will be changed to Compressed. */
  object.type = PDF_OBJECT_UNCOMPRESSED;
  object.u.offset = _cairo_output_stream_get_position (surface->output);

  status = _cairo_array_append (&surface->objects, &object);
  if (unlikely (status)(__builtin_expect (!!(status), 0))) {
resource.id = 0;
return resource;
  }

  resource = surface->next_available_resource;
  surface->next_available_resource.id++;

  return resource;
372}

374void
375_cairo_pdf_surface_update_object (cairo_pdf_surface_t	*surface,
		  cairo_pdf_resource_t	 resource)
377{
  cairo_pdf_object_t *object;

  object = _cairo_array_index (&surface->objects, resource.id - 1);
  object->u.offset = _cairo_output_stream_get_position (surface->output);
382}

384static void
385_cairo_pdf_surface_set_size_internal (cairo_pdf_surface_t *surface,
		      double		  width,
		      double		  height)
388{
  surface->width = width;
  surface->height = height;
  surface->surface_extents.x = 0;
  surface->surface_extents.y = 0;
  surface->surface_extents.width  = ceil (surface->width);
  surface->surface_extents.height = ceil (surface->height);
395}

397static cairo_bool_t
398_path_covers_bbox (cairo_pdf_surface_t *surface,
   cairo_path_fixed_t *path)
400{
  cairo_box_t box;

  return _cairo_path_fixed_is_box (path, &box) &&
  box.p1.x <= 0 &&
  box.p1.y <= 0 &&
  box.p2.x >= _cairo_fixed_from_double (surface->width) &&
  box.p2.y >= _cairo_fixed_from_double (surface->height);
408}

410static cairo_status_t
411_cairo_pdf_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)
416{
  cairo_pdf_surface_t *surface = cairo_container_of (clipper,({ const __typeof__ (((cairo_pdf_surface_t *) 0)->clipper)
 *mptr__ = (clipper); (cairo_pdf_surface_t *) ((char *) mptr__
 - __builtin_offsetof(cairo_pdf_surface_t, clipper)); })
				       cairo_pdf_surface_t,({ const __typeof__ (((cairo_pdf_surface_t *) 0)->clipper)
 *mptr__ = (clipper); (cairo_pdf_surface_t *) ((char *) mptr__
 - __builtin_offsetof(cairo_pdf_surface_t, clipper)); })
				       clipper)({ const __typeof__ (((cairo_pdf_surface_t *) 0)->clipper)
 *mptr__ = (clipper); (cairo_pdf_surface_t *) ((char *) mptr__
 - __builtin_offsetof(cairo_pdf_surface_t, clipper)); });
  cairo_int_status_t status;

  status = _cairo_pdf_operators_flush (&surface->pdf_operators);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (path == NULL((void*)0)) {
_cairo_output_stream_printf (surface->output, "Q q\n");

surface->current_pattern_is_solid_color = FALSE0;
surface->current_operator = CAIRO_OPERATOR_OVER;
_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);
440}

442static cairo_surface_t *
443_cairo_pdf_surface_create_for_stream_internal (cairo_output_stream_t	*output,
			       double			 width,
			       double			 height)
446{
  cairo_pdf_surface_t *surface;
  cairo_status_t status, status_ignored;

  surface = _cairo_calloc (sizeof (cairo_pdf_surface_t))((sizeof (cairo_pdf_surface_t)) != 0 ? calloc(1,sizeof (cairo_pdf_surface_t
)) : ((void*)0));
  if (unlikely (surface == NULL)(__builtin_expect (!!(surface == ((void*)0)), 0))) {
/* destroy stream on behalf of caller */
status = _cairo_output_stream_destroy (output);
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
  }

  _cairo_surface_init (&surface->base,
	 &cairo_pdf_surface_backend,
	 NULL((void*)0), /* device */
	 CAIRO_CONTENT_COLOR_ALPHA,
	 TRUE1); /* is_vector */

  surface->output = output;
  surface->width = width;
  surface->height = height;
  cairo_matrix_init_moz_cairo_matrix_init (&surface->cairo_to_pdf, 1, 0, 0, 1, 0, 0);
  surface->in_xobject = FALSE0;
  surface->surface_extents.x = 0;
  surface->surface_extents.y = 0;
  surface->surface_extents.width  = ceil (surface->width);
  surface->surface_extents.height = ceil (surface->height);
  surface->surface_bounded = TRUE1;

  _cairo_array_init (&surface->objects, sizeof (cairo_pdf_object_t));
  _cairo_array_init (&surface->pages, sizeof (cairo_pdf_page_info_t));
  _cairo_array_init (&surface->rgb_linear_functions, sizeof (cairo_pdf_rgb_linear_function_t));
  _cairo_array_init (&surface->alpha_linear_functions, sizeof (cairo_pdf_alpha_linear_function_t));
  _cairo_array_init (&surface->fonts, sizeof (cairo_pdf_font_t));
  _cairo_array_init (&surface->smask_groups, sizeof (cairo_pdf_smask_group_t *));
  _cairo_array_init (&surface->knockout_group, sizeof (cairo_pdf_resource_t));

  _cairo_array_init (&surface->page_patterns, sizeof (cairo_pdf_pattern_t));
  _cairo_array_init (&surface->page_surfaces, sizeof (cairo_pdf_source_surface_t));
  _cairo_array_init (&surface->doc_surfaces, sizeof (cairo_pdf_source_surface_t));
  _cairo_array_init (&surface->jbig2_global, sizeof (cairo_pdf_jbig2_global_t));
  surface->all_surfaces = _cairo_hash_table_create (_cairo_pdf_source_surface_equal);
  if (unlikely (surface->all_surfaces == NULL)(__builtin_expect (!!(surface->all_surfaces == ((void*)0))
, 0))) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto BAIL0;
  }

  surface->color_glyphs = _cairo_hash_table_create (_cairo_pdf_color_glyph_equal);
  if (unlikely (surface->color_glyphs == NULL)(__builtin_expect (!!(surface->color_glyphs == ((void*)0))
, 0))) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto BAIL1;
  }

  surface->duplicate_surface_number = 0;

  _cairo_pdf_group_resources_init (&surface->resources);

  surface->font_subsets = _cairo_scaled_font_subsets_create_composite ();
  if (! surface->font_subsets) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto BAIL2;
  }

  _cairo_scaled_font_subsets_enable_latin_subset (surface->font_subsets, TRUE1);

  surface->next_available_resource.id = 1;
  surface->pages_resource = _cairo_pdf_surface_new_object (surface);
  if (surface->pages_resource.id == 0) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
      goto BAIL3;
  }

  surface->struct_tree_root.id = 0;
  surface->pdf_version = CAIRO_PDF_VERSION_1_7;
  surface->compress_streams = TRUE1;
  surface->pdf_stream.active = FALSE0;
  surface->pdf_stream.old_output = NULL((void*)0);
  surface->group_stream.active = FALSE0;
  surface->group_stream.stream = NULL((void*)0);
  surface->group_stream.mem_stream = NULL((void*)0);
  surface->object_stream.active = FALSE0;
  surface->object_stream.stream = NULL((void*)0);
  _cairo_array_init (&surface->object_stream.objects, sizeof (cairo_xref_stream_object_t));

  surface->paginated_mode = CAIRO_PAGINATED_MODE_ANALYZE;
  surface->type3_replay = FALSE0;

  surface->force_fallbacks = FALSE0;
  surface->select_pattern_gstate_saved = FALSE0;
  surface->current_pattern_is_solid_color = FALSE0;
  surface->current_operator = CAIRO_OPERATOR_OVER;
  surface->reset_gs_required = FALSE0;
  surface->header_emitted = FALSE0;

  _cairo_surface_clipper_init (&surface->clipper,
		 _cairo_pdf_surface_clipper_intersect_clip_path);

  _cairo_pdf_operators_init (&surface->pdf_operators,
	       surface->output,
	       &surface->cairo_to_pdf,
	       surface->font_subsets,
	       FALSE0);
  _cairo_pdf_operators_set_font_subsets_callback (&surface->pdf_operators,
				    _cairo_pdf_surface_add_font,
				    surface);
  _cairo_pdf_operators_enable_actual_text(&surface->pdf_operators, TRUE1);

  status = _cairo_pdf_interchange_init (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto BAIL3;

  surface->page_parent_tree = -1;
  _cairo_array_init (&surface->page_annots, sizeof (cairo_pdf_resource_t));
  surface->tagged = FALSE0;
  surface->current_page_label = NULL((void*)0);
  _cairo_array_init (&surface->page_labels, sizeof (char *));
  surface->outlines_dict_res.id = 0;
  surface->names_dict_res.id = 0;
  surface->docinfo_res.id = 0;
  surface->page_labels_res.id = 0;
  surface->thumbnail_width = 0;
  surface->thumbnail_height = 0;
  surface->thumbnail_image = NULL((void*)0);

  surface->debug = FALSE0;
  if (getenv ("CAIRO_DEBUG_PDF") != NULL((void*)0)) {
surface->debug = TRUE1;
surface->compress_streams = FALSE0;
  }

  surface->paginated_surface =  _cairo_paginated_surface_create (
                                 &surface->base,
			  CAIRO_CONTENT_COLOR_ALPHA,
			  &cairo_pdf_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_moz_cairo_surface_destroy (&surface->base);
return surface->paginated_surface;
  }

587BAIL3:
  _cairo_scaled_font_subsets_destroy (surface->font_subsets);
589BAIL2:
  _cairo_hash_table_destroy (surface->color_glyphs);
591BAIL1:
  _cairo_hash_table_destroy (surface->all_surfaces);
593BAIL0:
  _cairo_array_fini (&surface->objects);
  free (surface);

  /* destroy stream on behalf of caller */
  status_ignored = _cairo_output_stream_destroy (output);

  return _cairo_surface_create_in_error (status);
601}

603/**
* cairo_pdf_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 PDF surface of the specified size in points to be written
* incrementally to the stream represented by @write_func and @closure.
*
* 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
**/
626cairo_surface_t *
627cairo_pdf_surface_create_for_stream_moz_cairo_pdf_surface_create_for_stream (cairo_write_func_t		 write_func,
		     void			*closure,
		     double			 width_in_points,
		     double			 height_in_points)
631{
  cairo_output_stream_t *output;

  output = _cairo_output_stream_create (write_func, NULL((void*)0), closure);
  if (_cairo_output_stream_get_status (output))
return _cairo_surface_create_in_error (_cairo_output_stream_destroy (output));

  return _cairo_pdf_surface_create_for_stream_internal (output,
					  width_in_points,
					  height_in_points);
641}

643/**
* cairo_pdf_surface_create:
* @filename: a filename for the PDF output (must be writable), %NULL may be
*            used to specify no output. This will generate a PDF 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 PDF surface of the specified size in points to be written
* to @filename.
*
* 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
**/
665cairo_surface_t *
666cairo_pdf_surface_create_moz_cairo_pdf_surface_create (const char		*filename,
	  double		 width_in_points,
	  double		 height_in_points)
669{
  cairo_output_stream_t *output;

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

  return _cairo_pdf_surface_create_for_stream_internal (output,
					  width_in_points,
					  height_in_points);
679}

681static cairo_bool_t
682_cairo_surface_is_pdf (cairo_surface_t *surface)
683{
  return surface->backend == &cairo_pdf_surface_backend;
685}

687/* If the abstract_surface is a paginated surface, and that paginated
* surface's target is a pdf_surface, then set pdf_surface to that
* target. Otherwise return FALSE.
*/
691static cairo_bool_t
692_extract_pdf_surface (cairo_surface_t		 *surface,
      cairo_pdf_surface_t	**pdf_surface)
694{
  cairo_surface_t *target;
  cairo_status_t status_ignored;

  if (surface->status)
return FALSE0;
  if (surface->finished) {
status_ignored = _cairo_surface_set_error (surface,
				   _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
      return FALSE0;
  }

  if (! _cairo_surface_is_paginated (surface)) {
status_ignored = _cairo_surface_set_error (surface,
				   _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH));
return FALSE0;
  }

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

  if (! _cairo_surface_is_pdf (target)) {
status_ignored = _cairo_surface_set_error (surface,
				   _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH));
return FALSE0;
  }

  *pdf_surface = (cairo_pdf_surface_t *) target;
  return TRUE1;
732}

734/**
* cairo_pdf_surface_restrict_to_version:
* @surface: a PDF #cairo_surface_t
* @version: PDF version
*
* Restricts the generated PDF file to @version. See cairo_pdf_get_versions()
* for a list of available version 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.10
**/
749void
750cairo_pdf_surface_restrict_to_version_moz_cairo_pdf_surface_restrict_to_version (cairo_surface_t 		*abstract_surface,
		       cairo_pdf_version_t  	 version)
752{
  cairo_pdf_surface_t *surface = NULL((void*)0); /* hide compiler warning */

  if (! _extract_pdf_surface (abstract_surface, &surface))
return;

  if (version < CAIRO_PDF_VERSION_LAST((int) (sizeof (_cairo_pdf_versions) / sizeof (_cairo_pdf_versions
[0]))))
surface->pdf_version = version;

  _cairo_pdf_operators_enable_actual_text(&surface->pdf_operators,
			    version >= CAIRO_PDF_VERSION_1_5);
763}

765/**
* cairo_pdf_get_versions:
* @versions: supported version list
* @num_versions: list length
*
* Used to retrieve the list of supported versions. See
* cairo_pdf_surface_restrict_to_version().
*
* Since: 1.10
**/
775void
776cairo_pdf_get_versions_moz_cairo_pdf_get_versions (cairo_pdf_version_t const	**versions,
                      int                     	 *num_versions)
778{
  if (versions != NULL((void*)0))
*versions = _cairo_pdf_versions;

  if (num_versions != NULL((void*)0))
*num_versions = CAIRO_PDF_VERSION_LAST((int) (sizeof (_cairo_pdf_versions) / sizeof (_cairo_pdf_versions
[0])));
784}

786/**
* cairo_pdf_version_to_string:
* @version: a version id
*
* Get the string representation of the given @version id. This function
* will return %NULL if @version isn't valid. See cairo_pdf_get_versions()
* for a way to get the list of valid version ids.
*
* Return value: the string associated to given version.
*
* Since: 1.10
**/
798const char *
799cairo_pdf_version_to_string_moz_cairo_pdf_version_to_string (cairo_pdf_version_t version)
800{
  if (version < 0 || version >= CAIRO_PDF_VERSION_LAST((int) (sizeof (_cairo_pdf_versions) / sizeof (_cairo_pdf_versions
[0]))))
return NULL((void*)0);

  return _cairo_pdf_version_strings[version];
805}

807/**
* cairo_pdf_surface_set_size:
* @surface: a PDF #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 PDF 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
**/
824void
825cairo_pdf_surface_set_size_moz_cairo_pdf_surface_set_size (cairo_surface_t	*surface,
	    double		 width_in_points,
	    double		 height_in_points)
828{
  cairo_pdf_surface_t *pdf_surface = NULL((void*)0); /* hide compiler warning */
  cairo_status_t status;

  if (! _extract_pdf_surface (surface, &pdf_surface))
return;

  _cairo_pdf_surface_set_size_internal (pdf_surface,
			  width_in_points,
			  height_in_points);
  status = _cairo_paginated_surface_set_size (pdf_surface->paginated_surface,
				width_in_points,
				height_in_points);
  if (status)
status = _cairo_surface_set_error (surface, status);
843}

845/**
* CAIRO_PDF_OUTLINE_ROOT:
*
* The root outline item in cairo_pdf_surface_add_outline().
*
* Since: 1.16
**/

853/**
* cairo_pdf_surface_add_outline:
* @surface: a PDF #cairo_surface_t
* @parent_id: the id of the parent item or %CAIRO_PDF_OUTLINE_ROOT if this is a top level item.
* @utf8: the name of the outline
* @link_attribs: the link attributes specifying where this outline links to
* @flags: outline item flags
*
* Add an item to the document outline hierarchy with the name @utf8
* that links to the location specified by @link_attribs. Link
* attributes have the same keys and values as the [Link Tag][link],
* excluding the "rect" attribute. The item will be a child of the
* item with id @parent_id. Use %CAIRO_PDF_OUTLINE_ROOT as the parent
* id of top level items.
*
* Return value: the id for the added item.
*
* Since: 1.16
**/
872int
873cairo_pdf_surface_add_outline (cairo_surface_t	         *surface,
	       int                        parent_id,
	       const char                *utf8,
	       const char                *link_attribs,
	       cairo_pdf_outline_flags_t  flags)
878{
  cairo_pdf_surface_t *pdf_surface = NULL((void*)0); /* hide compiler warning */
  cairo_status_t status;
  int id = 0;

  if (! _extract_pdf_surface (surface, &pdf_surface))
return 0;

  status = _cairo_pdf_interchange_add_outline (pdf_surface,
				 parent_id,
				 utf8,
				 link_attribs,
				 flags,
				 &id);
  if (status)
status = _cairo_surface_set_error (surface, status);

  return id;
896}

898/**
* cairo_pdf_surface_set_metadata:
* @surface: a PDF #cairo_surface_t
* @metadata: The metadata item to set.
* @utf8: metadata value
*
* Set document metadata. The %CAIRO_PDF_METADATA_CREATE_DATE and
* %CAIRO_PDF_METADATA_MOD_DATE values must be in ISO-8601 format:
* YYYY-MM-DDThh:mm:ss. An optional timezone of the form "[+/-]hh:mm"
* or "Z" for UTC time can be appended. All other metadata values can be any UTF-8
* string.
*
* For example:
* <informalexample><programlisting>
* cairo_pdf_surface_set_metadata (surface, CAIRO_PDF_METADATA_TITLE, "My Document");
* cairo_pdf_surface_set_metadata (surface, CAIRO_PDF_METADATA_CREATE_DATE, "2015-12-31T23:59+02:00");
* </programlisting></informalexample>
*
* Since: 1.16
**/
918void
919cairo_pdf_surface_set_metadata (cairo_surface_t      *surface,
		cairo_pdf_metadata_t  metadata,
                              const char           *utf8)
922{
  cairo_pdf_surface_t *pdf_surface = NULL((void*)0); /* hide compiler warning */
  cairo_status_t status;

  if (! _extract_pdf_surface (surface, &pdf_surface))
return;

  status = _cairo_pdf_interchange_set_metadata (pdf_surface, metadata, utf8);
  if (status)
status = _cairo_surface_set_error (surface, status);
932}

934/**
* cairo_pdf_surface_set_custom_metadata:
* @surface: a PDF #cairo_surface_t
* @name: The name of the custom metadata item to set (utf8).
* @value: The value of the metadata (utf8).
*
* Set custom document metadata. @name may be any string except for
* the following names reserved by PDF: "Title", "Author", "Subject",
* "Keywords", "Creator", "Producer", "CreationDate", "ModDate",
* "Trapped".
*
* If @value is NULL or an empty string, the @name metadata will not be set.
*
* For example:
* <informalexample><programlisting>
* cairo_pdf_surface_set_custom_metadata (surface, "ISBN", "978-0123456789");
* </programlisting></informalexample>
*
* Since: 1.18
**/
954void
955cairo_pdf_surface_set_custom_metadata (cairo_surface_t	    *surface,
                                     const char           *name,
                                     const char           *value)
958{
  cairo_pdf_surface_t *pdf_surface = NULL((void*)0); /* hide compiler warning */
  cairo_status_t status;

  if (! _extract_pdf_surface (surface, &pdf_surface))
return;

  status = _cairo_pdf_interchange_set_custom_metadata (pdf_surface, name, value);
  if (status)
status = _cairo_surface_set_error (surface, status);
968}

970/**
* cairo_pdf_surface_set_page_label:
* @surface: a PDF #cairo_surface_t
* @utf8: The page label.
*
* Set page label for the current page.
*
* Since: 1.16
**/
979void
980cairo_pdf_surface_set_page_label (cairo_surface_t *surface,
                                const char      *utf8)
982{
  cairo_pdf_surface_t *pdf_surface = NULL((void*)0); /* hide compiler warning */

  if (! _extract_pdf_surface (surface, &pdf_surface))
return;

  free (pdf_surface->current_page_label);
  pdf_surface->current_page_label = utf8 ? strdup (utf8) : NULL((void*)0);
990}

992/**
* cairo_pdf_surface_set_thumbnail_size:
* @surface: a PDF #cairo_surface_t
* @width: Thumbnail width.
* @height: Thumbnail height
*
* Set the thumbnail image size for the current and all subsequent
* pages. Setting a width or height of 0 disables thumbnails for the
* current and subsequent pages.
*
* Since: 1.16
**/
1004void
1005cairo_pdf_surface_set_thumbnail_size (cairo_surface_t *surface,
		      int              width,
		      int              height)
1008{
  cairo_pdf_surface_t *pdf_surface = NULL((void*)0); /* hide compiler warning */

  if (! _extract_pdf_surface (surface, &pdf_surface))
return;

  pdf_surface->thumbnail_width = width;
  pdf_surface->thumbnail_height = height;
1016}

1018static void
1019_cairo_pdf_surface_clear (cairo_pdf_surface_t *surface,
	  cairo_bool_t         clear_doc_surfaces)
1021{
  int i, size;
  cairo_pdf_pattern_t *pattern;
  cairo_pdf_source_surface_t *src_surface;
  cairo_pdf_smask_group_t *group;
  cairo_pdf_source_surface_t doc_surface;

  size = _cairo_array_num_elements (&surface->page_patterns);
  for (i = 0; i < size; i++) {
pattern = (cairo_pdf_pattern_t *) _cairo_array_index (&surface->page_patterns, i);
cairo_pattern_destroy_moz_cairo_pattern_destroy (pattern->pattern);
  }
  _cairo_array_truncate (&surface->page_patterns, 0);

  size = _cairo_array_num_elements (&surface->page_surfaces);
  for (i = 0; i < size; i++) {
src_surface = (cairo_pdf_source_surface_t *) _cairo_array_index (&surface->page_surfaces, i);
if (src_surface->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE) {
   cairo_pattern_destroy_moz_cairo_pattern_destroy (src_surface->raster_pattern);
} else {
   if (_cairo_surface_is_recording (src_surface->surface) && src_surface->region_id != 0)
_cairo_recording_surface_region_array_remove (src_surface->surface, src_surface->region_id);
   cairo_surface_destroy_moz_cairo_surface_destroy (src_surface->surface);
}
  }
  _cairo_array_truncate (&surface->page_surfaces, 0);

  size = _cairo_array_num_elements (&surface->smask_groups);
  for (i = 0; i < size; i++) {
_cairo_array_copy_element (&surface->smask_groups, i, &group);
_cairo_pdf_smask_group_destroy (group);
  }
  _cairo_array_truncate (&surface->smask_groups, 0);
  _cairo_array_truncate (&surface->knockout_group, 0);
  _cairo_array_truncate (&surface->page_annots, 0);

  if (surface->thumbnail_image)
cairo_surface_destroy_moz_cairo_surface_destroy (&surface->thumbnail_image->base);
  surface->thumbnail_image = NULL((void*)0);

  if (clear_doc_surfaces) {
size = _cairo_array_num_elements (&surface->doc_surfaces);
for (i = 0; i < size; i++) {
   _cairo_array_copy_element (&surface->doc_surfaces, i, &doc_surface);
   if (doc_surface.type == CAIRO_PATTERN_TYPE_RASTER_SOURCE) {
cairo_pattern_destroy_moz_cairo_pattern_destroy (doc_surface.raster_pattern);
   } else {
if (_cairo_surface_is_recording (doc_surface.surface) && doc_surface.region_id != 0)
    _cairo_recording_surface_region_array_remove (doc_surface.surface, doc_surface.region_id);
cairo_surface_destroy_moz_cairo_surface_destroy (doc_surface.surface);
   }
}
_cairo_array_truncate (&surface->doc_surfaces, 0);
  }
1075}

1077static void
1078_cairo_pdf_group_resources_init (cairo_pdf_group_resources_t *res)
1079{
  int i;

  for (i = 0; i < CAIRO_NUM_OPERATORS(CAIRO_OPERATOR_HSL_LUMINOSITY + 1); i++)
res->operators[i] = FALSE0;

  _cairo_array_init (&res->alphas, sizeof (double));
  _cairo_array_init (&res->smasks, sizeof (cairo_pdf_resource_t));
  _cairo_array_init (&res->patterns, sizeof (cairo_pdf_resource_t));
  _cairo_array_init (&res->shadings, sizeof (cairo_pdf_resource_t));
  _cairo_array_init (&res->xobjects, sizeof (cairo_pdf_resource_t));
  _cairo_array_init (&res->fonts, sizeof (cairo_pdf_font_t));
1091}

1093static void
1094_cairo_pdf_group_resources_fini (cairo_pdf_group_resources_t *res)
1095{
  _cairo_array_fini (&res->alphas);
  _cairo_array_fini (&res->smasks);
  _cairo_array_fini (&res->patterns);
  _cairo_array_fini (&res->shadings);
  _cairo_array_fini (&res->xobjects);
  _cairo_array_fini (&res->fonts);
1102}

1104static void
1105_cairo_pdf_group_resources_clear (cairo_pdf_group_resources_t *res)
1106{
  int i;

  for (i = 0; i < CAIRO_NUM_OPERATORS(CAIRO_OPERATOR_HSL_LUMINOSITY + 1); i++)
res->operators[i] = FALSE0;

  _cairo_array_truncate (&res->alphas, 0);
  _cairo_array_truncate (&res->smasks, 0);
  _cairo_array_truncate (&res->patterns, 0);
  _cairo_array_truncate (&res->shadings, 0);
  _cairo_array_truncate (&res->xobjects, 0);
  _cairo_array_truncate (&res->fonts, 0);
1118}

1120static void
1121_cairo_pdf_surface_add_operator (cairo_pdf_surface_t *surface,
		 cairo_operator_t     op)
1123{
  cairo_pdf_group_resources_t *res = &surface->resources;

  res->operators[op] = TRUE1;
1127}

1129static cairo_int_status_t
1130_cairo_pdf_surface_add_alpha (cairo_pdf_surface_t *surface,
	      double               alpha,
	      int                 *index)
1133{
  int num_alphas, i;
  double other;
  cairo_int_status_t status;
  cairo_pdf_group_resources_t *res = &surface->resources;

  num_alphas = _cairo_array_num_elements (&res->alphas);
  for (i = 0; i < num_alphas; i++) {
_cairo_array_copy_element (&res->alphas, i, &other);
if (alpha == other) {
   *index = i;
   return CAIRO_STATUS_SUCCESS;
}
  }

  status = _cairo_array_append (&res->alphas, &alpha);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  *index = _cairo_array_num_elements (&res->alphas) - 1;

  return CAIRO_STATUS_SUCCESS;
1155}

1157static cairo_int_status_t
1158_cairo_pdf_surface_add_smask (cairo_pdf_surface_t  *surface,
	      cairo_pdf_resource_t  smask)
1160{
  return _cairo_array_append (&(surface->resources.smasks), &smask);
1162}

1164static cairo_int_status_t
1165_cairo_pdf_surface_add_pattern (cairo_pdf_surface_t  *surface,
		cairo_pdf_resource_t  pattern)
1167{
  return _cairo_array_append (&(surface->resources.patterns), &pattern);
1169}

1171static cairo_int_status_t
1172_cairo_pdf_surface_add_shading (cairo_pdf_surface_t  *surface,
		cairo_pdf_resource_t  shading)
1174{
  return _cairo_array_append (&(surface->resources.shadings), &shading);
1176}


1179static cairo_int_status_t
1180_cairo_pdf_surface_add_xobject (cairo_pdf_surface_t  *surface,
		cairo_pdf_resource_t  xobject)
1182{
  return _cairo_array_append (&(surface->resources.xobjects), &xobject);
1184}

1186static cairo_int_status_t
1187_cairo_pdf_surface_add_font (unsigned int        font_id,
	     unsigned int        subset_id,
	     void		*closure)
1190{
  cairo_pdf_surface_t *surface = closure;
  cairo_pdf_font_t font;
  int num_fonts, i;
  cairo_int_status_t status;
  cairo_pdf_group_resources_t *res = &surface->resources;

  num_fonts = _cairo_array_num_elements (&res->fonts);
  for (i = 0; i < num_fonts; i++) {
_cairo_array_copy_element (&res->fonts, i, &font);
if (font.font_id == font_id &&
   font.subset_id == subset_id)
   return CAIRO_STATUS_SUCCESS;
  }

  num_fonts = _cairo_array_num_elements (&surface->fonts);
  for (i = 0; i < num_fonts; i++) {
_cairo_array_copy_element (&surface->fonts, i, &font);
if (font.font_id == font_id &&
   font.subset_id == subset_id)
   return _cairo_array_append (&res->fonts, &font);
  }

  font.font_id = font_id;
  font.subset_id = subset_id;
  font.subset_resource = _cairo_pdf_surface_new_object (surface);
  if (font.subset_resource.id == 0)
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  status = _cairo_array_append (&surface->fonts, &font);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  return _cairo_array_append (&res->fonts, &font);
1224}

1226static cairo_pdf_resource_t
1227_cairo_pdf_surface_get_font_resource (cairo_pdf_surface_t *surface,
		      unsigned int         font_id,
		      unsigned int         subset_id)
1230{
  cairo_pdf_font_t font;
  int num_fonts, i;

  num_fonts = _cairo_array_num_elements (&surface->fonts);
  for (i = 0; i < num_fonts; i++) {
_cairo_array_copy_element (&surface->fonts, i, &font);
if (font.font_id == font_id && font.subset_id == subset_id)
   return font.subset_resource;
  }

  font.subset_resource.id = 0;
  return font.subset_resource;
1243}

1245static const char *
1246_cairo_operator_to_pdf_blend_mode (cairo_operator_t op)
1247{
  switch (op) {
  /* The extend blend mode operators */
  case CAIRO_OPERATOR_MULTIPLY:       return "Multiply";
  case CAIRO_OPERATOR_SCREEN:         return "Screen";
  case CAIRO_OPERATOR_OVERLAY:        return "Overlay";
  case CAIRO_OPERATOR_DARKEN:         return "Darken";
  case CAIRO_OPERATOR_LIGHTEN:        return "Lighten";
  case CAIRO_OPERATOR_COLOR_DODGE:    return "ColorDodge";
  case CAIRO_OPERATOR_COLOR_BURN:     return "ColorBurn";
  case CAIRO_OPERATOR_HARD_LIGHT:     return "HardLight";
  case CAIRO_OPERATOR_SOFT_LIGHT:     return "SoftLight";
  case CAIRO_OPERATOR_DIFFERENCE:     return "Difference";
  case CAIRO_OPERATOR_EXCLUSION:      return "Exclusion";
  case CAIRO_OPERATOR_HSL_HUE:        return "Hue";
  case CAIRO_OPERATOR_HSL_SATURATION: return "Saturation";
  case CAIRO_OPERATOR_HSL_COLOR:      return "Color";
  case CAIRO_OPERATOR_HSL_LUMINOSITY: return "Luminosity";

  default:
  /* The original Porter-Duff set */
  case CAIRO_OPERATOR_CLEAR:
  case CAIRO_OPERATOR_SOURCE:
  case CAIRO_OPERATOR_OVER:
  case CAIRO_OPERATOR_IN:
  case CAIRO_OPERATOR_OUT:
  case CAIRO_OPERATOR_ATOP:
  case CAIRO_OPERATOR_DEST:
  case CAIRO_OPERATOR_DEST_OVER:
  case CAIRO_OPERATOR_DEST_IN:
  case CAIRO_OPERATOR_DEST_OUT:
  case CAIRO_OPERATOR_DEST_ATOP:
  case CAIRO_OPERATOR_XOR:
  case CAIRO_OPERATOR_ADD:
  case CAIRO_OPERATOR_SATURATE:
return "Normal";
  }
1284}

1286static void
1287_cairo_pdf_surface_emit_group_resources (cairo_pdf_surface_t         *surface,
			 cairo_pdf_group_resources_t *res,
			 cairo_bool_t                 gs0)
1290{
  int num_alphas, num_smasks, num_resources, i;
  double alpha;
  cairo_pdf_resource_t *smask, *pattern, *shading, *xobject;
  cairo_pdf_font_t *font;

  _cairo_output_stream_printf (surface->output, "<<\n");

  num_alphas = _cairo_array_num_elements (&res->alphas);
  num_smasks = _cairo_array_num_elements (&res->smasks);
  if (num_alphas > 0 || num_smasks > 0) {
_cairo_output_stream_printf (surface->output,
		     "   /ExtGState <<\n");

if (gs0) {
   _cairo_output_stream_printf (surface->output,
			 "      /gs0 << /BM /Normal /SMask /None /CA 1.0 /ca 1.0 >>\n");
}

for (i = 0; i < CAIRO_NUM_OPERATORS(CAIRO_OPERATOR_HSL_LUMINOSITY + 1); i++) {
   if (res->operators[i]) {
_cairo_output_stream_printf (surface->output,
			     "      /b%d << /BM /%s >>\n",
			     i, _cairo_operator_to_pdf_blend_mode(i));
   }
}

for (i = 0; i < num_alphas; i++) {
   _cairo_array_copy_element (&res->alphas, i, &alpha);
   _cairo_output_stream_printf (surface->output,
			 "      /a%d << /CA %f /ca %f >>\n",
			 i, alpha, alpha);
}

for (i = 0; i < num_smasks; i++) {
   smask = _cairo_array_index (&res->smasks, i);
   _cairo_output_stream_printf (surface->output,
			 "      /s%d %d 0 R\n",
			 smask->id, smask->id);
}

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

  num_resources = _cairo_array_num_elements (&res->patterns);
  if (num_resources > 0) {
_cairo_output_stream_printf (surface->output,
		     "   /Pattern <<");
for (i = 0; i < num_resources; i++) {
   pattern = _cairo_array_index (&res->patterns, i);
   _cairo_output_stream_printf (surface->output,
			 " /p%d %d 0 R",
			 pattern->id, pattern->id);
}

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

  num_resources = _cairo_array_num_elements (&res->shadings);
  if (num_resources > 0) {
_cairo_output_stream_printf (surface->output,
		     "   /Shading <<");
for (i = 0; i < num_resources; i++) {
   shading = _cairo_array_index (&res->shadings, i);
   _cairo_output_stream_printf (surface->output,
			 " /sh%d %d 0 R",
			 shading->id, shading->id);
}

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

  num_resources = _cairo_array_num_elements (&res->xobjects);
  if (num_resources > 0) {
_cairo_output_stream_printf (surface->output,
		     "   /XObject <<");

for (i = 0; i < num_resources; i++) {
   xobject = _cairo_array_index (&res->xobjects, i);
   _cairo_output_stream_printf (surface->output,
			 " /x%d %d 0 R",
			 xobject->id, xobject->id);
}

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

  num_resources = _cairo_array_num_elements (&res->fonts);
  if (num_resources > 0) {
_cairo_output_stream_printf (surface->output,"   /Font <<\n");
for (i = 0; i < num_resources; i++) {
   font = _cairo_array_index (&res->fonts, i);
   _cairo_output_stream_printf (surface->output,
			 "      /f-%d-%d %d 0 R\n",
			 font->font_id,
			 font->subset_id,
			 font->subset_resource.id);
}
_cairo_output_stream_printf (surface->output, "   >>\n");
  }

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

1399static cairo_pdf_smask_group_t *
1400_cairo_pdf_surface_create_smask_group (cairo_pdf_surface_t	    *surface,
		       const cairo_rectangle_int_t  *extents)
1402{
  cairo_pdf_smask_group_t	*group;

  group = _cairo_calloc (sizeof (cairo_pdf_smask_group_t))((sizeof (cairo_pdf_smask_group_t)) != 0 ? calloc(1,sizeof (cairo_pdf_smask_group_t
)) : ((void*)0));
  if (unlikely (group == NULL)(__builtin_expect (!!(group == ((void*)0)), 0))) {
_cairo_error_throw (CAIRO_STATUS_NO_MEMORY)do { cairo_status_t status__ = _cairo_error (CAIRO_STATUS_NO_MEMORY
); (void) status__; } while (0);
return NULL((void*)0);
  }

  group->group_res = _cairo_pdf_surface_new_object (surface);
  if (group->group_res.id == 0) {
_cairo_error_throw (CAIRO_STATUS_NO_MEMORY)do { cairo_status_t status__ = _cairo_error (CAIRO_STATUS_NO_MEMORY
); (void) status__; } while (0);
free (group);
return NULL((void*)0);
  }
  group->width = surface->width;
  group->height = surface->height;
  if (extents != NULL((void*)0)) {
group->extents = *extents;
  } else {
group->extents.x = 0;
group->extents.y = 0;
group->extents.width = surface->width;
group->extents.height = surface->height;
  }

  return group;
1429}

1431static void
1432_cairo_pdf_smask_group_destroy (cairo_pdf_smask_group_t *group)
1433{
  if (group->operation == PDF_FILL ||	group->operation == PDF_STROKE)
_cairo_path_fixed_fini (&group->path);
  if (group->source)
cairo_pattern_destroy_moz_cairo_pattern_destroy (group->source);
  if (group->mask)
cairo_pattern_destroy_moz_cairo_pattern_destroy (group->mask);
  free (group->utf8);
  free (group->glyphs);
  free (group->clusters);
  if (group->scaled_font)
cairo_scaled_font_destroy_moz_cairo_scaled_font_destroy (group->scaled_font);
  free (group);
1446}

1448static cairo_int_status_t
1449_cairo_pdf_surface_add_smask_group (cairo_pdf_surface_t     *surface,
		    cairo_pdf_smask_group_t *group)
1451{
  return _cairo_array_append (&surface->smask_groups, &group);
1453}

1455static cairo_bool_t
1456_cairo_pdf_source_surface_equal (const void *key_a, const void *key_b)
1457{
  const cairo_pdf_source_surface_entry_t *a = key_a;
  const cairo_pdf_source_surface_entry_t *b = key_b;

  if (a->interpolate != b->interpolate)
return FALSE0;

  if (a->region_id != b->region_id)
return FALSE0;

  if (a->unique_id && b->unique_id && a->unique_id_length == b->unique_id_length)
return (memcmp (a->unique_id, b->unique_id, a->unique_id_length) == 0);

  return (a->id == b->id);
1471}

1473static void
1474_cairo_pdf_source_surface_init_key (cairo_pdf_source_surface_entry_t *key)
1475{
  if (key->unique_id && key->unique_id_length > 0) {
15
←
Assuming field 'unique_id' is null→
key->base.hash = _cairo_hash_bytes (_CAIRO_HASH_INIT_VALUE5381,
			    key->unique_id, key->unique_id_length);
  } else {
key->base.hash = key->id;
  }
  key->base.hash = _cairo_hash_bytes (key->base.hash,
			&key->region_id,
			sizeof(key->region_id));
1485}
16
←
Returning without writing to 'key->unique_id', which participates in a condition later→

1487static cairo_bool_t
1488_cairo_pdf_color_glyph_equal (const void *key_a, const void *key_b)
1489{
  const cairo_pdf_color_glyph_t *a = key_a;
  const cairo_pdf_color_glyph_t *b = key_b;

  if (a->scaled_font != b->scaled_font)
return FALSE0;

  return (a->glyph_index == b->glyph_index);
1497}

1499static void
1500_cairo_pdf_color_glyph_init_key (cairo_pdf_color_glyph_t *key)
1501{
  key->base.hash = _cairo_hash_uintptr (_CAIRO_HASH_INIT_VALUE5381, (uintptr_t)key->scaled_font);
  key->base.hash = _cairo_hash_uintptr (key->base.hash, key->glyph_index);
1504}

1506static cairo_int_status_t
1507_cairo_pdf_surface_acquire_source_image_from_pattern (cairo_pdf_surface_t          *surface,
				      const cairo_pattern_t        *pattern,
				      cairo_image_surface_t       **image,
				      void                        **image_extra)
1511{
  switch (pattern->type) {
  case CAIRO_PATTERN_TYPE_SURFACE: {
cairo_surface_pattern_t *surf_pat = (cairo_surface_pattern_t *) pattern;
return _cairo_surface_acquire_source_image (surf_pat->surface, image, image_extra);
  } break;

  case CAIRO_PATTERN_TYPE_RASTER_SOURCE: {
cairo_surface_t *surf;
surf = _cairo_raster_source_pattern_acquire (pattern, &surface->base, NULL((void*)0));
if (!surf)
   return CAIRO_INT_STATUS_UNSUPPORTED;
assert (_cairo_surface_is_image (surf))((void) sizeof (__assert_single_arg (_cairo_surface_is_image (
surf))), __extension__ ({ if (_cairo_surface_is_image (surf))
 ; else __assert_fail ("_cairo_surface_is_image (surf)", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 1523, __extension__ __PRETTY_FUNCTION__); }));
*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_REACHEDdo { ((void) sizeof (__assert_single_arg (!"reached")), __extension__
 ({ if (!"reached") ; else __assert_fail ("!\"reached\"", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 1532, __extension__ __PRETTY_FUNCTION__); })); } while (0);
break;
  }

  return CAIRO_STATUS_SUCCESS;
1537}

1539static void
1540_cairo_pdf_surface_release_source_image_from_pattern (cairo_pdf_surface_t          *surface,
				      const cairo_pattern_t        *pattern,
				      cairo_image_surface_t        *image,
				      void                         *image_extra)
1544{
  switch (pattern->type) {
  case CAIRO_PATTERN_TYPE_SURFACE: {
cairo_surface_pattern_t *surf_pat = (cairo_surface_pattern_t *) pattern;
_cairo_surface_release_source_image (surf_pat->surface, image, image_extra);
  } break;

  case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
_cairo_raster_source_pattern_release (pattern, &image->base);
break;

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

ASSERT_NOT_REACHEDdo { ((void) sizeof (__assert_single_arg (!"reached")), __extension__
 ({ if (!"reached") ; else __assert_fail ("!\"reached\"", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 1561, __extension__ __PRETTY_FUNCTION__); })); } while (0);
break;
  }
1564}

1566static cairo_int_status_t
1567_get_source_surface_extents (cairo_surface_t         *source,
	     cairo_rectangle_int_t   *extents,
	     cairo_bool_t            *bounded,
	     cairo_bool_t            *subsurface)
1571{
  cairo_int_status_t status;

  *bounded = TRUE1;
  *subsurface = FALSE0;
  if (source->type == CAIRO_SURFACE_TYPE_RECORDING) {
cairo_surface_t *free_me = NULL((void*)0);

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

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

   *extents = sub->extents;
   *subsurface = TRUE1;
} else {
   cairo_box_t box;

   *bounded = _cairo_surface_get_extents (source, extents);
   if (! *bounded) {
status = _cairo_recording_surface_get_ink_bbox ((cairo_recording_surface_t *)source,
						&box, NULL((void*)0));
if (unlikely (status)(__builtin_expect (!!(status), 0))) {
    cairo_surface_destroy_moz_cairo_surface_destroy (free_me);
    return status;
}
_cairo_box_round_to_rectangle (&box, extents);
   }
}
cairo_surface_destroy_moz_cairo_surface_destroy (free_me);
  } else {
*bounded =  _cairo_surface_get_extents (source, extents);
  }

  return CAIRO_STATUS_SUCCESS;
1607}

1609/**
* _cairo_pdf_surface_add_source_surface:
* @surface: [in] the pdf surface
* @source_surface: [in] A #cairo_surface_t to use as the source surface
* @source_pattern: [in] A #cairo_pattern_t of type SURFACE or RASTER_SOURCE to use as the source
* @region_id: [in] Surfaces containing tags set this to the recording
* surface region id. When tags are used in a XObject, PDF requires a
* separate object for each use (section 14.7.4.2) @region_id is used
* as a key to ensure a separate object is emitted for each use. Set
* to 0 for surfaces without tags.
* @op: [in] the operator used to composite this source
* @filter: [in] filter type of the source pattern
* @stencil_mask: [in] if true, the surface will be written to the PDF as an /ImageMask
* @smask: [in] if true, only the alpha channel will be written (images only)
* @need_transp_group: [in] if true and an XObject is used, make it a Transparency group
* @extents: [in] extents of the operation that is using this source
* @smask_res: [in] if not NULL, the image written will specify this resource as the smask for
* the image (images only)
* @pdf_source: [out] return pdf_source_surface entry in hash table
* @x_offset: [out] if not NULL return x offset of surface
* @y_offset: [out] if not NULL return y offset of surface
* @source_extents: [out] if not NULL return operation extents in source space
*
* Add surface or raster_source pattern to list of surfaces to be
* written to the PDF file when the current page is finished. Returns
* a PDF resource to reference the surface. A hash table of all
* surfaces in the PDF file (keyed by CAIRO_MIME_TYPE_UNIQUE_ID or
* surface unique_id) is used to ensure surfaces with the same id are
* only written once to the PDF file.
*
* Only one of @source_pattern or @source_surface is to be
* specified. Set the other to NULL.
**/
1642static cairo_int_status_t
1643_cairo_pdf_surface_add_source_surface (cairo_pdf_surface_t	         *surface,
		       cairo_surface_t	                 *source_surface,
		       const cairo_pattern_t	         *source_pattern,
		       int                                region_id,
		       cairo_operator_t                   op,
		       cairo_filter_t		          filter,
		       cairo_bool_t                       stencil_mask,
		       cairo_bool_t                       smask,
		       cairo_bool_t                       need_transp_group,
		       const cairo_rectangle_int_t       *extents,
		       cairo_pdf_resource_t	         *smask_res,
		       cairo_pdf_source_surface_entry_t **pdf_source,
		       double                            *x_offset,
		       double                            *y_offset,
		       cairo_rectangle_int_t             *source_extents)
1658{
  cairo_pdf_source_surface_t src_surface;
  cairo_pdf_source_surface_entry_t surface_key;
  cairo_pdf_source_surface_entry_t *surface_entry;
  cairo_int_status_t status = CAIRO_STATUS_SUCCESS;
  cairo_bool_t interpolate;
  unsigned char *unique_id = NULL((void*)0);
  unsigned long unique_id_length = 0;
  cairo_image_surface_t *image;
  void *image_extra;
  cairo_box_t box;
  cairo_rectangle_int_t op_extents;
  double x, y;
  cairo_bool_t subsurface;
  cairo_bool_t emit_image;

  switch (filter) {
1
Control jumps to 'case CAIRO_FILTER_GAUSSIAN:'  at line 1683→
  default:
  case CAIRO_FILTER_GOOD:
  case CAIRO_FILTER_BEST:
  case CAIRO_FILTER_BILINEAR:
interpolate = TRUE1;
break;
  case CAIRO_FILTER_FAST:
  case CAIRO_FILTER_NEAREST:
  case CAIRO_FILTER_GAUSSIAN:
interpolate = FALSE0;
break;
2
←
 Execution continues on line 1688→
  }

  x = 0;
  y = 0;
  if (source_pattern) {
3
←
Assuming 'source_pattern' is null→
4
←
Taking false branch→
if (source_pattern->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE) {
   status = _cairo_pdf_surface_acquire_source_image_from_pattern (surface, source_pattern,
							   &image, &image_extra);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;
   source_surface = &image->base;
   cairo_surface_get_device_offset_moz_cairo_surface_get_device_offset (source_surface, &x, &y);
} else {
   cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) source_pattern;
   source_surface = surface_pattern->surface;
}
  }
  if (x_offset)
5
←
Assuming 'x_offset' is non-null→
6
←
Taking true branch→
*x_offset = x;
  if (y_offset)
7
←
Assuming 'y_offset' is null→
8
←
Taking false branch→
*y_offset = y;

  /* transform operation extents to pattern space */
  op_extents = *extents;
  if (source_pattern8.1
'source_pattern' is null
)
9
←
Taking false branch→
  {
_cairo_box_from_rectangle (&box, extents);
_cairo_matrix_transform_bounding_box_fixed (&source_pattern->matrix, &box, NULL((void*)0));
_cairo_box_round_to_rectangle (&box, &op_extents);
  }
  if (source_extents)
10
←
Assuming 'source_extents' is null→
11
←
Taking false branch→
*source_extents = op_extents;

  surface_key.id  = source_surface->unique_id;

  /* Recording surfaces do not use interpolate. Ensure it is always
   * false for recording surfaces. This is because pdf-interchange
   * needs to lookup recording surfaces in the hash table using
   * interpolate = FALSE in the key since it does not know the
   * interpolate value passed to this function.
   */
  emit_image = source_surface->type != CAIRO_SURFACE_TYPE_RECORDING;
12
←
Assuming field 'type' is equal to CAIRO_SURFACE_TYPE_RECORDING→
  surface_key.interpolate = emit_image12.1
'emit_image' is 0
 ? interpolate : FALSE0;
13
←
'?' condition is false→

  cairo_surface_get_mime_data_moz_cairo_surface_get_mime_data (source_surface, CAIRO_MIME_TYPE_UNIQUE_ID"application/x-cairo.uuid",
		 (const unsigned char **) &surface_key.unique_id,
		 &surface_key.unique_id_length);

  surface_key.region_id = region_id;
  _cairo_pdf_source_surface_init_key (&surface_key);
14
←
Calling '_cairo_pdf_source_surface_init_key'→
17
←
Returning from '_cairo_pdf_source_surface_init_key'→
  surface_entry = _cairo_hash_table_lookup (surface->all_surfaces, &surface_key.base);
  if (surface_entry) {
18
←
Assuming 'surface_entry' is null→
if (pdf_source)
   *pdf_source = surface_entry;

if (source_pattern && source_pattern->extend != CAIRO_EXTEND_NONE)
   _cairo_unbounded_rectangle_init (&op_extents);

_cairo_rectangle_intersect (&op_extents, &surface_entry->extents);
_cairo_rectangle_union (&surface_entry->required_extents, &op_extents);
status = CAIRO_STATUS_SUCCESS;
  }

  if (status18.1
'status' is 0
 || surface_entry18.2
'surface_entry' is null
) {
if (source_pattern && source_pattern->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE)
   _cairo_pdf_surface_release_source_image_from_pattern (surface, source_pattern, image, image_extra);
return status;
  }

  if (surface_key.unique_id && surface_key.unique_id_length > 0) {
19
←
Assuming field 'unique_id' is null→
unique_id = _cairo_malloc (surface_key.unique_id_length)((surface_key.unique_id_length) != 0 ? malloc(surface_key.unique_id_length
) : ((void*)0));
if (unique_id == NULL((void*)0)) {
   status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
   goto fail1;
}

unique_id_length = surface_key.unique_id_length;
   memcpy (unique_id, surface_key.unique_id, unique_id_length);
  } else {
unique_id = NULL((void*)0);
unique_id_length = 0;
  }

  surface_entry = _cairo_calloc (sizeof (cairo_pdf_source_surface_entry_t))((sizeof (cairo_pdf_source_surface_entry_t)) != 0 ? calloc(1,
sizeof (cairo_pdf_source_surface_entry_t)) : ((void*)0));
20
←
'?' condition is true→
  if (surface_entry == NULL((void*)0)) {
21
←
Assuming 'surface_entry' is not equal to NULL→
22
←
Taking false branch→
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto fail1;
  }

  if (pdf_source)
23
←
Assuming 'pdf_source' is null→
24
←
Taking false branch→
*pdf_source = surface_entry;

  surface_entry->id = surface_key.id;
  surface_entry->region_id = region_id;
  surface_entry->operator = op;
  surface_entry->interpolate = emit_image24.1
'emit_image' is 0
 ? interpolate : FALSE0;
25
←
'?' condition is false→
  surface_entry->emit_image = emit_image;
  surface_entry->stencil_mask = stencil_mask;
  surface_entry->smask = smask;
  surface_entry->need_transp_group = need_transp_group;
  surface_entry->unique_id_length = unique_id_length;
  surface_entry->unique_id = unique_id;
  if (smask_res)
26
←
Assuming 'smask_res' is null→
27
←
Taking false branch→
surface_entry->smask_res = *smask_res;
  else
surface_entry->smask_res.id = 0;

  status = _get_source_surface_extents (source_surface,
			  &surface_entry->extents,
			  &surface_entry->bounded,
			  &subsurface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
28
←
Assuming 'status' is 0→
29
←
Taking false branch→
goto fail2;

  if (subsurface) {
30
←
Assuming 'subsurface' is not equal to 0→
31
←
Taking true branch→
*x_offset = -surface_entry->extents.x;
*y_offset = -surface_entry->extents.y;
32
←
Dereference of null pointer (loaded from variable 'y_offset')
  }

  if (source_pattern && source_pattern->extend != CAIRO_EXTEND_NONE)
_cairo_unbounded_rectangle_init (&op_extents);

  _cairo_rectangle_intersect (&op_extents, &surface_entry->extents);
  surface_entry->required_extents = op_extents;

  _cairo_pdf_source_surface_init_key (surface_entry);

  src_surface.hash_entry = surface_entry;
  src_surface.region_id = 0;
  if (source_pattern && source_pattern->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE) {
src_surface.type = CAIRO_PATTERN_TYPE_RASTER_SOURCE;
src_surface.surface = NULL((void*)0);
status = _cairo_pattern_create_copy (&src_surface.raster_pattern, source_pattern);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto fail2;

  } else {
src_surface.type = CAIRO_PATTERN_TYPE_SURFACE;
src_surface.surface = cairo_surface_reference_moz_cairo_surface_reference (source_surface);
src_surface.raster_pattern = NULL((void*)0);
if (source_pattern) {
   cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) source_pattern;
   src_surface.region_id = surface_pattern->region_array_id;
   if (_cairo_surface_is_recording (surface_pattern->surface) &&
surface_pattern->region_array_id != 0)
   {
_cairo_recording_surface_region_array_reference (surface_pattern->surface,
						 surface_pattern->region_array_id);
   }
}
  }

  surface_entry->surface_res = _cairo_pdf_surface_new_object (surface);
  if (surface_entry->surface_res.id == 0) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto fail3;
  }

  if (surface_entry->bounded) {
status = _cairo_array_append (&surface->page_surfaces, &src_surface);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto fail3;
  } else {
status = _cairo_array_append (&surface->doc_surfaces, &src_surface);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto fail3;
  }

  status = _cairo_hash_table_insert (surface->all_surfaces,
		       &surface_entry->base);
  if (unlikely(status)(__builtin_expect (!!(status), 0)))
goto fail3;

  if (source_pattern && source_pattern->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE)
_cairo_pdf_surface_release_source_image_from_pattern (surface, source_pattern, image, image_extra);

  return CAIRO_STATUS_SUCCESS;

1864fail3:
  if (source_pattern && source_pattern->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE)
cairo_pattern_destroy_moz_cairo_pattern_destroy (src_surface.raster_pattern);
  else
cairo_surface_destroy_moz_cairo_surface_destroy (src_surface.surface);

1870fail2:
  free (surface_entry);

1873fail1:
  if (unique_id)
free (unique_id);

  if (source_pattern && source_pattern->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE)
_cairo_pdf_surface_release_source_image_from_pattern (surface, source_pattern, image, image_extra);

  return status;
1881}

1883static cairo_int_status_t
1884_cairo_pdf_surface_add_pdf_pattern_or_shading (cairo_pdf_surface_t	   *surface,
			       const cairo_pattern_t	   *pattern,
			       cairo_operator_t	            op,
			       cairo_analysis_source_t      source_type,
			       const cairo_rectangle_int_t *extents,
			       cairo_bool_t                 is_shading,
			       cairo_pdf_resource_t	   *pattern_res,
			       cairo_pdf_resource_t	   *gstate_res)
1892{
  cairo_pdf_pattern_t pdf_pattern;
  cairo_int_status_t status;
  int region_id = 0;

  pdf_pattern.is_shading = is_shading;
  pdf_pattern.operator = op;

  /* Solid colors are emitted into the content stream */
  if (pattern->type == CAIRO_PATTERN_TYPE_SOLID) {
pattern_res->id = 0;
gstate_res->id = 0;
return CAIRO_INT_STATUS_SUCCESS;
  }

  status = _cairo_pattern_create_copy (&pdf_pattern.pattern, pattern);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  pdf_pattern.pattern_res = _cairo_pdf_surface_new_object (surface);
  if (pdf_pattern.pattern_res.id == 0) {
cairo_pattern_destroy_moz_cairo_pattern_destroy (pdf_pattern.pattern);
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
  }

  pdf_pattern.gstate_res.id = 0;

  /* gradient patterns require an smask object to implement transparency */
  if (pattern->type == CAIRO_PATTERN_TYPE_LINEAR ||
pattern->type == CAIRO_PATTERN_TYPE_RADIAL ||
pattern->type == CAIRO_PATTERN_TYPE_MESH)
  {
double min_alpha;

_cairo_pattern_alpha_range (pattern, &min_alpha, NULL((void*)0));
if (! CAIRO_ALPHA_IS_OPAQUE (min_alpha)((min_alpha) >= ((double)0xff00 / (double)0xffff))) {
          pdf_pattern.gstate_res = _cairo_pdf_surface_new_object (surface);
   if (pdf_pattern.gstate_res.id == 0) {
cairo_pattern_destroy_moz_cairo_pattern_destroy (pdf_pattern.pattern);
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
   }
      }
  }

  pdf_pattern.width  = surface->width;
  pdf_pattern.height = surface->height;
  if (extents != NULL((void*)0)) {
pdf_pattern.extents = *extents;
  } else {
pdf_pattern.extents.x = 0;
pdf_pattern.extents.y = 0;
pdf_pattern.extents.width  = surface->width;
pdf_pattern.extents.height = surface->height;
  }

  *pattern_res = pdf_pattern.pattern_res;
  *gstate_res = pdf_pattern.gstate_res;
  /* If the pattern requires a gstate it will be drawn from within
   * an XObject. The initial space of each XObject has an inverted
   * Y-axis. */
  pdf_pattern.inverted_y_axis = pdf_pattern.gstate_res.id ? TRUE1 : surface->in_xobject;

  if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE) {
cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) pattern;
if (_cairo_pdf_interchange_struct_tree_requires_recording_surface (surface,
							   surface_pattern,
							   source_type))
{
   region_id = surface_pattern->region_array_id;
}
  }
  pdf_pattern.region_id = region_id;

  status = _cairo_array_append (&surface->page_patterns, &pdf_pattern);
  if (unlikely (status)(__builtin_expect (!!(status), 0))) {
cairo_pattern_destroy_moz_cairo_pattern_destroy (pdf_pattern.pattern);
return status;
  }

  return CAIRO_INT_STATUS_SUCCESS;
1972}

1974/* Get BBox from extents */
1975static void
1976_get_bbox_from_extents (const cairo_rectangle_int_t  *extents,
	cairo_box_double_t           *bbox)
1978{
  bbox->p1.x = extents->x;
  bbox->p1.y = extents->y;
  bbox->p2.x = extents->x + extents->width;
  bbox->p2.y = extents->y + extents->height;
1983}

1985static cairo_int_status_t
1986_cairo_pdf_surface_add_pdf_shading (cairo_pdf_surface_t		*surface,
		    const cairo_pattern_t	*pattern,
		    cairo_operator_t	         op,
		    const cairo_rectangle_int_t	*extents,
		    cairo_pdf_resource_t	*shading_res,
		    cairo_pdf_resource_t	*gstate_res)
1992{
  return _cairo_pdf_surface_add_pdf_pattern_or_shading (surface,
					  pattern,
					  op,
					  CAIRO_ANALYSIS_SOURCE_NONE,
					  extents,
					  TRUE1,
					  shading_res,
					  gstate_res);
2001}

2003static cairo_int_status_t
2004_cairo_pdf_surface_add_pdf_pattern (cairo_pdf_surface_t		*surface,
		    const cairo_pattern_t	*pattern,
		    cairo_operator_t	         op,
		    cairo_analysis_source_t      source_type,
		    const cairo_rectangle_int_t	*extents,
		    cairo_pdf_resource_t	*pattern_res,
		    cairo_pdf_resource_t	*gstate_res)
2011{
  return _cairo_pdf_surface_add_pdf_pattern_or_shading (surface,
					  pattern,
					  op,
					  source_type,
					  extents,
					  FALSE0,
					  pattern_res,
					  gstate_res);
2020}

2022static cairo_int_status_t
2023_cairo_pdf_surface_open_stream (cairo_pdf_surface_t	*surface,
		cairo_pdf_resource_t    *resource,
		cairo_bool_t             compressed,
		const char		*fmt,
		...)
2028{
  va_list ap;
  cairo_pdf_resource_t self, length;
  cairo_output_stream_t *output = NULL((void*)0);

  if (resource) {
self = *resource;
_cairo_pdf_surface_update_object (surface, self);
  } else {
self = _cairo_pdf_surface_new_object (surface);
if (self.id == 0)
   return _cairo_error (CAIRO_STATUS_NO_MEMORY);
  }

  length = _cairo_pdf_surface_new_object (surface);
  if (length.id == 0)
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  if (compressed) {
output = _cairo_deflate_stream_create (surface->output);
if (_cairo_output_stream_get_status (output))
   return _cairo_output_stream_destroy (output);
  }

  surface->pdf_stream.active = TRUE1;
  surface->pdf_stream.self = self;
  surface->pdf_stream.length = length;
  surface->pdf_stream.compressed = compressed;
  surface->current_pattern_is_solid_color = FALSE0;
  surface->current_operator = CAIRO_OPERATOR_OVER;
  _cairo_pdf_operators_reset (&surface->pdf_operators);

  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /Length %d 0 R\n",
		 surface->pdf_stream.self.id,
		 surface->pdf_stream.length.id);
  if (compressed)
_cairo_output_stream_printf (surface->output,
		     "   /Filter /FlateDecode\n");

  if (fmt != NULL((void*)0)) {
va_start (ap, fmt)__builtin_va_start(ap, fmt);
_cairo_output_stream_vprintf (surface->output, fmt, ap);
va_end (ap)__builtin_va_end(ap);
  }

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

  surface->pdf_stream.start_offset = _cairo_output_stream_get_position (surface->output);

  if (compressed) {
assert (surface->pdf_stream.old_output == NULL)((void) sizeof (__assert_single_arg (surface->pdf_stream.old_output
 == ((void*)0))), __extension__ ({ if (surface->pdf_stream
.old_output == ((void*)0)) ; else __assert_fail ("surface->pdf_stream.old_output == NULL"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 2082, __extension__ __PRETTY_FUNCTION__); }));
      surface->pdf_stream.old_output = surface->output;
      surface->output = output;
_cairo_pdf_operators_set_stream (&surface->pdf_operators, surface->output);
  }
  _cairo_pdf_operators_reset (&surface->pdf_operators);

  return _cairo_output_stream_get_status (surface->output);
2090}

2092static cairo_int_status_t
2093_cairo_pdf_surface_close_stream (cairo_pdf_surface_t *surface)
2094{
  cairo_int_status_t status;
  long long length;

  if (! surface->pdf_stream.active)
return CAIRO_INT_STATUS_SUCCESS;

  status = _cairo_pdf_operators_flush (&surface->pdf_operators);

  if (surface->pdf_stream.compressed) {
cairo_int_status_t status2;

status2 = _cairo_output_stream_destroy (surface->output);
if (likely (status == CAIRO_INT_STATUS_SUCCESS)(__builtin_expect (!!(status == CAIRO_INT_STATUS_SUCCESS), 1)
))
   status = status2;

surface->output = surface->pdf_stream.old_output;
_cairo_pdf_operators_set_stream (&surface->pdf_operators, surface->output);
surface->pdf_stream.old_output = NULL((void*)0);
  }

  length = _cairo_output_stream_get_position (surface->output) -
surface->pdf_stream.start_offset;
  _cairo_output_stream_printf (surface->output,
		 "\n"
		 "endstream\n"
		 "endobj\n");

  _cairo_pdf_surface_update_object (surface,
		      surface->pdf_stream.length);
  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "   %lld\n"
		 "endobj\n",
		 surface->pdf_stream.length.id,
		 length);

  surface->pdf_stream.active = FALSE0;

  if (likely (status == CAIRO_INT_STATUS_SUCCESS)(__builtin_expect (!!(status == CAIRO_INT_STATUS_SUCCESS), 1)
))
status = _cairo_output_stream_get_status (surface->output);

  return status;
2137}

2139static void
2140_cairo_pdf_surface_write_memory_stream (cairo_pdf_surface_t         *surface,
			cairo_output_stream_t       *mem_stream,
			cairo_pdf_resource_t         resource,
			cairo_pdf_group_resources_t *resources,
			cairo_bool_t                 is_knockout_group,
			const cairo_box_double_t    *bbox)
2146{
  _cairo_pdf_surface_update_object (surface, resource);

  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /Type /XObject\n"
		 "   /Length %d\n",
		 resource.id,
		 _cairo_memory_stream_length (mem_stream));

  if (surface->compress_streams) {
_cairo_output_stream_printf (surface->output,
		     "   /Filter /FlateDecode\n");
  }

  _cairo_output_stream_printf (surface->output,
		 "   /Subtype /Form\n"
		 "   /BBox [ %f %f %f %f ]\n"
		 "   /Group <<\n"
		 "      /Type /Group\n"
		 "      /S /Transparency\n"
		 "      /I true\n"
		 "      /CS /DeviceRGB\n",
		 bbox->p1.x, bbox->p1.y, bbox->p2.x, bbox->p2.y);

  if (is_knockout_group)
      _cairo_output_stream_printf (surface->output,
                                   "      /K true\n");

  _cairo_output_stream_printf (surface->output,
		 "   >>\n"
		 "   /Resources\n");
  _cairo_pdf_surface_emit_group_resources (surface, resources, TRUE1);
  _cairo_output_stream_printf (surface->output,
		 ">>\n"
		 "stream\n");
  _cairo_memory_stream_copy (mem_stream, surface->output);
  _cairo_output_stream_printf (surface->output,
		 "endstream\n"
		 "endobj\n");
2186}

2188static cairo_int_status_t
2189_cairo_pdf_surface_open_group (cairo_pdf_surface_t         *surface,
	       const cairo_box_double_t    *bbox,
	       cairo_pdf_resource_t        *resource)
2192{
  cairo_int_status_t status;

  assert (surface->pdf_stream.active == FALSE)((void) sizeof (__assert_single_arg (surface->pdf_stream.active
 == 0)), __extension__ ({ if (surface->pdf_stream.active ==
 0) ; else __assert_fail ("surface->pdf_stream.active == FALSE"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 2195, __extension__ __PRETTY_FUNCTION__); }));
  assert (surface->group_stream.active == FALSE)((void) sizeof (__assert_single_arg (surface->group_stream
.active == 0)), __extension__ ({ if (surface->group_stream
.active == 0) ; else __assert_fail ("surface->group_stream.active == FALSE"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 2196, __extension__ __PRETTY_FUNCTION__); }));

  surface->group_stream.active = TRUE1;

  surface->group_stream.mem_stream = _cairo_memory_stream_create ();

  if (surface->compress_streams) {
surface->group_stream.stream =
   _cairo_deflate_stream_create (surface->group_stream.mem_stream);
  } else {
surface->group_stream.stream = surface->group_stream.mem_stream;
  }
  status = _cairo_output_stream_get_status (surface->group_stream.stream);

  surface->group_stream.old_output = surface->output;
  surface->output = surface->group_stream.stream;
  _cairo_pdf_operators_set_stream (&surface->pdf_operators, surface->output);
  _cairo_pdf_group_resources_clear (&surface->resources);

  if (resource) {
surface->group_stream.resource = *resource;
  } else {
surface->group_stream.resource = _cairo_pdf_surface_new_object (surface);
if (surface->group_stream.resource.id == 0)
   return _cairo_error (CAIRO_STATUS_NO_MEMORY);
  }
  surface->group_stream.is_knockout = FALSE0;
  surface->group_stream.bbox = *bbox;

  /* Reset gstate */
  surface->reset_gs_required = TRUE1;
  surface->current_pattern_is_solid_color = FALSE0;
  surface->current_operator = CAIRO_OPERATOR_OVER;
  _cairo_pdf_operators_reset (&surface->pdf_operators);

  return status;
2232}

2234static cairo_int_status_t
2235_cairo_pdf_surface_open_knockout_group (cairo_pdf_surface_t         *surface,
			const cairo_box_double_t    *bbox)
2237{
  cairo_int_status_t status;

  status = _cairo_pdf_surface_open_group (surface, bbox, NULL((void*)0));
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  surface->group_stream.is_knockout = TRUE1;

  return CAIRO_INT_STATUS_SUCCESS;
2247}

2249static cairo_int_status_t
2250_cairo_pdf_surface_close_group (cairo_pdf_surface_t *surface,
		cairo_pdf_resource_t *group)
2252{
  cairo_int_status_t status = CAIRO_INT_STATUS_SUCCESS, status2;

  assert (surface->pdf_stream.active == FALSE)((void) sizeof (__assert_single_arg (surface->pdf_stream.active
 == 0)), __extension__ ({ if (surface->pdf_stream.active ==
 0) ; else __assert_fail ("surface->pdf_stream.active == FALSE"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 2255, __extension__ __PRETTY_FUNCTION__); }));
  assert (surface->group_stream.active == TRUE)((void) sizeof (__assert_single_arg (surface->group_stream
.active == 1)), __extension__ ({ if (surface->group_stream
.active == 1) ; else __assert_fail ("surface->group_stream.active == TRUE"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 2256, __extension__ __PRETTY_FUNCTION__); }));

  status = _cairo_pdf_operators_flush (&surface->pdf_operators);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (surface->compress_streams) {
status = _cairo_output_stream_destroy (surface->group_stream.stream);
surface->group_stream.stream = NULL((void*)0);

_cairo_output_stream_printf (surface->group_stream.mem_stream,
		     "\n");
  }
  surface->output = surface->group_stream.old_output;
  _cairo_pdf_operators_set_stream (&surface->pdf_operators, surface->output);
  surface->group_stream.active = FALSE0;
  _cairo_pdf_surface_write_memory_stream (surface,
			    surface->group_stream.mem_stream,
			    surface->group_stream.resource,
			    &surface->resources,
			    surface->group_stream.is_knockout,
			    &surface->group_stream.bbox);
  if (group)
*group = surface->group_stream.resource;

  status2 = _cairo_output_stream_destroy (surface->group_stream.mem_stream);
  if (status == CAIRO_INT_STATUS_SUCCESS)
status = status2;

  surface->group_stream.mem_stream = NULL((void*)0);
  surface->group_stream.stream = NULL((void*)0);
  surface->reset_gs_required = FALSE0;

  return status;
2290}

2292static cairo_int_status_t
2293_cairo_pdf_surface_open_object_stream (cairo_pdf_surface_t *surface)
2294{
  if (surface->debug || surface->pdf_version < CAIRO_PDF_VERSION_1_5) {
/* Object streams not supported. All objects will be written
* directly to the file. */
assert (surface->pdf_stream.active == FALSE)((void) sizeof (__assert_single_arg (surface->pdf_stream.active
 == 0)), __extension__ ({ if (surface->pdf_stream.active ==
 0) ; else __assert_fail ("surface->pdf_stream.active == FALSE"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 2298, __extension__ __PRETTY_FUNCTION__); }));
assert (surface->group_stream.active == FALSE)((void) sizeof (__assert_single_arg (surface->group_stream
.active == 0)), __extension__ ({ if (surface->group_stream
.active == 0) ; else __assert_fail ("surface->group_stream.active == FALSE"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 2299, __extension__ __PRETTY_FUNCTION__); }));
surface->object_stream.stream = surface->output;
  } else {
surface->object_stream.resource = _cairo_pdf_surface_new_object (surface);
if (surface->object_stream.resource.id == 0)
   return _cairo_error (CAIRO_STATUS_NO_MEMORY);

_cairo_array_truncate (&surface->object_stream.objects, 0);
surface->object_stream.stream = _cairo_memory_stream_create ();
surface->object_stream.active = TRUE1;
  }
  return _cairo_output_stream_get_status (surface->object_stream.stream);
2311}

2313cairo_int_status_t
2314_cairo_pdf_surface_object_begin (cairo_pdf_surface_t *surface,
		 cairo_pdf_resource_t resource)
2316{
  cairo_xref_stream_object_t xref_obj;
  cairo_pdf_object_t *object;
  cairo_int_status_t status;

  if (surface->object_stream.active) {
xref_obj.resource = resource;
xref_obj.offset = _cairo_output_stream_get_position (surface->object_stream.stream);
status = _cairo_array_append (&surface->object_stream.objects, &xref_obj);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

object = _cairo_array_index (&surface->objects, resource.id - 1);
object->type = PDF_OBJECT_COMPRESSED;
object->u.compressed_obj.xref_stream = surface->object_stream.resource;
object->u.compressed_obj.index = _cairo_array_num_elements (&surface->object_stream.objects) - 1;

  } else {
_cairo_pdf_surface_update_object (surface, resource);
_cairo_output_stream_printf (surface->output,
		     "%d 0 obj\n",
		     resource.id);
  }
  return CAIRO_INT_STATUS_SUCCESS;
2340}

2342void
2343_cairo_pdf_surface_object_end (cairo_pdf_surface_t *surface)
2344{
  if (!surface->object_stream.active) {
_cairo_output_stream_printf (surface->output,
		     "endobj\n");
  }
2349}

2351static int
2352_cairo_xref_stream_object_compare (const void *a,
		   const void *b)
2354{
  const cairo_xref_stream_object_t *a_obj = a;
  const cairo_xref_stream_object_t *b_obj = b;

  if (a_obj->offset < b_obj->offset)
return -1;
  else if (a_obj->offset > b_obj->offset)
return 1;
  else
return 0;
2364}

2366static cairo_int_status_t
2367_cairo_pdf_surface_close_object_stream (cairo_pdf_surface_t *surface)
2368{
  int i, num_objects;
  cairo_xref_stream_object_t *xref_obj;
  long long start_pos, length;
  cairo_output_stream_t *index_stream;
  cairo_output_stream_t *deflate_stream;
  cairo_pdf_resource_t length_res;
  cairo_int_status_t status;
  cairo_pdf_object_t *object;

  if (!surface->object_stream.active) {
surface->object_stream.stream = NULL((void*)0);
return CAIRO_INT_STATUS_SUCCESS;
  }

  num_objects = _cairo_array_num_elements (&surface->object_stream.objects);
  if (num_objects == 0) {
object = _cairo_array_index (&surface->objects, surface->object_stream.resource.id - 1);
object->type = PDF_OBJECT_FREE;
return CAIRO_INT_STATUS_SUCCESS;
  }

  index_stream = _cairo_memory_stream_create ();
  /* PDF requires the object id/offset pairs to be sorted by offset. */
  _cairo_array_sort (&surface->object_stream.objects, _cairo_xref_stream_object_compare);
  for (i = 0; i < num_objects; i++) {
xref_obj = _cairo_array_index (&surface->object_stream.objects, i);
_cairo_output_stream_printf (index_stream,
		     "%d %lld\n",
		     xref_obj->resource.id,
		     xref_obj->offset);
  }

  length_res = _cairo_pdf_surface_new_object (surface);
  if (length_res.id == 0)
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  _cairo_pdf_surface_update_object (surface, surface->object_stream.resource);
  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /Type /ObjStm\n"
                               "   /Length %d 0 R\n"
                               "   /N %d\n"
                               "   /First %d\n",
		 surface->object_stream.resource.id,
		 length_res.id,
		 num_objects,
		 _cairo_memory_stream_length (index_stream));

  if (surface->compress_streams) {
_cairo_output_stream_printf (surface->output,
		     "   /Filter /FlateDecode\n");
  }

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

  start_pos = _cairo_output_stream_get_position (surface->output);
  if (surface->compress_streams) {
deflate_stream = _cairo_deflate_stream_create (surface->output);
_cairo_memory_stream_copy (index_stream, deflate_stream);
_cairo_memory_stream_copy (surface->object_stream.stream, deflate_stream);
status = _cairo_output_stream_destroy (deflate_stream);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

length = _cairo_output_stream_get_position (surface->output) - start_pos;
  } else {
_cairo_memory_stream_copy (index_stream, surface->output);
_cairo_memory_stream_copy (surface->object_stream.stream, surface->output);
length = _cairo_output_stream_get_position (surface->output) - start_pos;
  }

  _cairo_output_stream_printf (surface->output,
		 "\n"
		 "endstream\n"
		 "endobj\n");

  _cairo_pdf_surface_update_object (surface,
		      length_res);
  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "   %lld\n"
		 "endobj\n",
		 length_res.id,
		 length);

  status = _cairo_output_stream_destroy (index_stream);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  status = _cairo_output_stream_destroy (surface->object_stream.stream);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  surface->object_stream.stream = NULL((void*)0);
  surface->object_stream.active = FALSE0;

  return _cairo_output_stream_get_status (surface->output);
2468}

2470static cairo_int_status_t
2471_cairo_pdf_surface_open_content_stream (cairo_pdf_surface_t       *surface,
			const cairo_box_double_t  *bbox,
			cairo_pdf_resource_t      *resource,
			cairo_bool_t               is_form,
			cairo_bool_t               is_group,
			int                        struct_parents)
2477{
  cairo_int_status_t status;

  assert (surface->pdf_stream.active == FALSE)((void) sizeof (__assert_single_arg (surface->pdf_stream.active
 == 0)), __extension__ ({ if (surface->pdf_stream.active ==
 0) ; else __assert_fail ("surface->pdf_stream.active == FALSE"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 2480, __extension__ __PRETTY_FUNCTION__); }));
  assert (surface->group_stream.active == FALSE)((void) sizeof (__assert_single_arg (surface->group_stream
.active == 0)), __extension__ ({ if (surface->group_stream
.active == 0) ; else __assert_fail ("surface->group_stream.active == FALSE"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 2481, __extension__ __PRETTY_FUNCTION__); }));

  surface->content_resources = _cairo_pdf_surface_new_object (surface);
  if (surface->content_resources.id == 0)
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  if (is_form) {
assert (bbox != NULL)((void) sizeof (__assert_single_arg (bbox != ((void*)0))), __extension__
 ({ if (bbox != ((void*)0)) ; else __assert_fail ("bbox != NULL"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 2488, __extension__ __PRETTY_FUNCTION__); }));

cairo_output_stream_t *mem_stream = _cairo_memory_stream_create ();
if (is_group) {
   _cairo_output_stream_printf (mem_stream,
     "   /Type /XObject\n"
     "   /Subtype /Form\n"
     "   /BBox [ %f %f %f %f ]\n"
     "   /Group <<\n"
     "      /Type /Group\n"
     "      /S /Transparency\n"
     "      /I true\n"
     "      /CS /DeviceRGB\n"
     "   >>\n"
     "   /Resources %d 0 R\n",
     bbox->p1.x,
     bbox->p1.y,
     bbox->p2.x,
     bbox->p2.y,
     surface->content_resources.id);
} else {
   _cairo_output_stream_printf (mem_stream,
     "   /Type /XObject\n"
     "   /Subtype /Form\n"
     "   /BBox [ %f %f %f %f ]\n"
     "   /Resources %d 0 R\n",
     bbox->p1.x,
     bbox->p1.y,
     bbox->p2.x,
     bbox->p2.y,
     surface->content_resources.id);
}
if (struct_parents >= 0) {
   _cairo_output_stream_printf (mem_stream,
"   /StructParents %d\n", struct_parents);
}

unsigned char *data;
unsigned long length;
status = _cairo_memory_stream_destroy (mem_stream, &data, &length);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

char *str = _cairo_strndupstrndup ((const char*)data, length); /* Add NULL terminator */

status =
   _cairo_pdf_surface_open_stream (surface,
			    resource,
			    surface->compress_streams,
			    "%s",
			    str);
free (str);
free (data);
  } else {
status =
   _cairo_pdf_surface_open_stream (surface,
			    resource,
			    surface->compress_streams,
			    NULL((void*)0));
_cairo_output_stream_printf (surface->output,
		     "1 0 0 -1 0 %f cm\n",
		     surface->height);
  }
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  surface->content = surface->pdf_stream.self;

  _cairo_output_stream_printf (surface->output, "q\n");
  _cairo_pdf_operators_reset (&surface->pdf_operators);

  return _cairo_output_stream_get_status (surface->output);
2560}

2562static cairo_int_status_t
2563_cairo_pdf_surface_close_content_stream (cairo_pdf_surface_t *surface,
			 cairo_bool_t         is_form)
2565{
  cairo_int_status_t status;

  assert (surface->pdf_stream.active == TRUE)((void) sizeof (__assert_single_arg (surface->pdf_stream.active
 == 1)), __extension__ ({ if (surface->pdf_stream.active ==
 1) ; else __assert_fail ("surface->pdf_stream.active == TRUE"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 2568, __extension__ __PRETTY_FUNCTION__); }));
  assert (surface->group_stream.active == FALSE)((void) sizeof (__assert_single_arg (surface->group_stream
.active == 0)), __extension__ ({ if (surface->group_stream
.active == 0) ; else __assert_fail ("surface->group_stream.active == FALSE"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 2569, __extension__ __PRETTY_FUNCTION__); }));

  status = _cairo_pdf_operators_flush (&surface->pdf_operators);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_output_stream_printf (surface->output, "Q\n");
  status = _cairo_pdf_surface_close_stream (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_pdf_surface_update_object (surface, surface->content_resources);
  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n",
		 surface->content_resources.id);
  _cairo_pdf_surface_emit_group_resources (surface, &surface->resources, is_form);
  _cairo_output_stream_printf (surface->output,
		 "endobj\n");

  return _cairo_output_stream_get_status (surface->output);
2589}

2591static void
2592_cairo_pdf_source_surface_entry_pluck (void *entry, void *closure)
2593{
  cairo_pdf_source_surface_entry_t *surface_entry = entry;
  cairo_hash_table_t *patterns = closure;

  _cairo_hash_table_remove (patterns, &surface_entry->base);
  free (surface_entry->unique_id);

  free (surface_entry);
2601}

2603static void
2604_cairo_pdf_color_glyph_pluck (void *entry, void *closure)
2605{
  cairo_pdf_color_glyph_t *glyph_entry = entry;
  cairo_hash_table_t *patterns = closure;

  _cairo_hash_table_remove (patterns, &glyph_entry->base);
  cairo_scaled_font_destroy_moz_cairo_scaled_font_destroy (glyph_entry->scaled_font);

  free (glyph_entry);
2613}

2615static cairo_int_status_t
2616_cairo_pdf_surface_write_page_dicts (cairo_pdf_surface_t *surface)
2617{
  cairo_int_status_t status;
  cairo_pdf_page_info_t *page_info;
  int num_annots;
  cairo_pdf_resource_t res;

  for (unsigned i = 0; i < _cairo_array_num_elements (&surface->pages); i++) {
page_info = _cairo_array_index (&surface->pages, i);

status = _cairo_pdf_surface_object_begin (surface, page_info->page_res);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

_cairo_output_stream_printf (surface->object_stream.stream,
		     "<< /Type /Page %% %d\n"
		     "   /Parent %d 0 R\n"
		     "   /MediaBox [ 0 0 %f %f ]\n"
		     "   /Contents %d 0 R\n"
		     "   /Group <<\n"
		     "      /Type /Group\n"
		     "      /S /Transparency\n"
		     "      /I true\n"
		     "      /CS /DeviceRGB\n"
		     "   >>\n"
		     "   /Resources %d 0 R\n",
		     i + 1,
		     surface->pages_resource.id,
		     page_info->width,
		     page_info->height,
		     page_info->content.id,
		     page_info->resources.id);

if (page_info->struct_parents >= 0) {
   _cairo_output_stream_printf (surface->object_stream.stream,
			 "   /StructParents %d\n",
			 page_info->struct_parents);
}

num_annots = _cairo_array_num_elements (&page_info->annots);
if (num_annots > 0) {
   _cairo_output_stream_printf (surface->object_stream.stream,
			 "   /Annots [ ");
   for (int j = 0; j < num_annots; j++) {
_cairo_array_copy_element (&page_info->annots, j, &res);
_cairo_output_stream_printf (surface->object_stream.stream,
			     "%d 0 R ",
			     res.id);
   }
   _cairo_output_stream_printf (surface->object_stream.stream, "]\n");
}

if (page_info->thumbnail.id) {
   _cairo_output_stream_printf (surface->object_stream.stream,
			 "   /Thumb %d 0 R\n",
			 page_info->thumbnail.id);
}

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

  return status;
2680}

2682static cairo_status_t
2683_cairo_pdf_surface_finish (void *abstract_surface)
2684{
  cairo_pdf_surface_t *surface = abstract_surface;
  long long offset;
  cairo_pdf_resource_t catalog;
  cairo_status_t status = CAIRO_STATUS_SUCCESS, status2;
  int size, i;
  cairo_pdf_jbig2_global_t *global;
  char *label;
  cairo_pdf_resource_t xref_res;

  /* Some of the data may be in an inconistent state if there is an error status. */
  if (surface->base.status != CAIRO_STATUS_SUCCESS)
goto CLEANUP;

  _cairo_pdf_surface_clear (surface, FALSE0);

  status = _cairo_pdf_surface_open_object_stream (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto CLEANUP;

  /* Emit unbounded surfaces */
  status = _cairo_pdf_surface_write_patterns_and_smask_groups (surface, TRUE1);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto CLEANUP;

  _cairo_pdf_surface_clear (surface, TRUE1);

  status = _cairo_pdf_surface_emit_font_subsets (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto CLEANUP;

  /* Emit any new patterns or surfaces created by the Type 3 font subset. */
  _cairo_pdf_surface_write_patterns_and_smask_groups (surface, TRUE1);

  _cairo_pdf_surface_clear (surface, TRUE1);

  status = _cairo_pdf_surface_write_pages (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto CLEANUP;

  status = _cairo_pdf_interchange_write_document_objects (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto CLEANUP;

  status = _cairo_pdf_surface_write_page_dicts (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto CLEANUP;

  catalog = _cairo_pdf_surface_new_object (surface);
  if (catalog.id == 0) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto CLEANUP;
  }

  status = _cairo_pdf_surface_write_catalog (surface, catalog);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto CLEANUP;

  status = _cairo_pdf_surface_close_object_stream (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto CLEANUP;

  if (!surface->debug && surface->pdf_version >= CAIRO_PDF_VERSION_1_5)
  {
xref_res = _cairo_pdf_surface_new_object (surface);
status = _cairo_pdf_surface_write_xref_stream (surface,
				       xref_res,
				       catalog,
				       surface->docinfo_res,
				       &offset);
  } else {
offset = _cairo_pdf_surface_write_xref (surface);
_cairo_output_stream_printf (surface->output,
		     "trailer\n"
		     "<< /Size %d\n"
		     "   /Root %d 0 R\n"
		     "   /Info %d 0 R\n"
		     ">>\n",
		     surface->next_available_resource.id,
		     catalog.id,
		     surface->docinfo_res.id);
  }
  _cairo_output_stream_printf (surface->output,
		 "startxref\n"
		 "%lld\n"
		 "%%%%EOF\n",
		 offset);

CLEANUP:

  /* pdf_operators has already been flushed when the last stream was
   * closed so we should never be writing anything here - however,
   * the stream may itself be in an error state. */
  status2 = _cairo_pdf_operators_fini (&surface->pdf_operators);
  if (status == CAIRO_STATUS_SUCCESS)
status = status2;

  /* close any active streams still open due to fatal errors */
  status2 = _cairo_pdf_surface_close_stream (surface);
  if (status == CAIRO_STATUS_SUCCESS)
status = status2;

  if (surface->group_stream.stream != NULL((void*)0)) {
status2 = _cairo_output_stream_destroy (surface->group_stream.stream);
if (status == CAIRO_STATUS_SUCCESS)
   status = status2;
  }
  if (surface->group_stream.mem_stream != NULL((void*)0)) {
status2 = _cairo_output_stream_destroy (surface->group_stream.mem_stream);
if (status == CAIRO_STATUS_SUCCESS)
   status = status2;
  }
  if (surface->pdf_stream.active)
surface->output = surface->pdf_stream.old_output;
  if (surface->group_stream.active)
surface->output = surface->group_stream.old_output;

  /* and finish the pdf surface */
  status2 = _cairo_output_stream_destroy (surface->output);
  if (status == CAIRO_STATUS_SUCCESS)
status = status2;

  _cairo_pdf_group_resources_fini (&surface->resources);

  _cairo_array_fini (&surface->objects);
  size = _cairo_array_num_elements (&surface->pages);
  for (i = 0; i < size; i++) {
cairo_pdf_page_info_t *page_info = _cairo_array_index (&surface->pages, i);
_cairo_array_fini (&page_info->annots);
  }
  _cairo_array_fini (&surface->pages);
  _cairo_array_fini (&surface->rgb_linear_functions);
  _cairo_array_fini (&surface->alpha_linear_functions);
  _cairo_array_fini (&surface->page_patterns);
  _cairo_array_fini (&surface->page_surfaces);
  _cairo_array_fini (&surface->object_stream.objects);

  _cairo_array_fini (&surface->doc_surfaces);
  _cairo_hash_table_foreach (surface->all_surfaces,
	       _cairo_pdf_source_surface_entry_pluck,
	       surface->all_surfaces);
  _cairo_hash_table_destroy (surface->all_surfaces);
  _cairo_array_fini (&surface->smask_groups);
  _cairo_array_fini (&surface->fonts);
  _cairo_array_fini (&surface->knockout_group);
  _cairo_array_fini (&surface->page_annots);

   _cairo_hash_table_foreach (surface->color_glyphs,
		_cairo_pdf_color_glyph_pluck,
		surface->color_glyphs);
   _cairo_hash_table_destroy (surface->color_glyphs);

  if (surface->font_subsets) {
_cairo_scaled_font_subsets_destroy (surface->font_subsets);
surface->font_subsets = NULL((void*)0);
  }

  size = _cairo_array_num_elements (&surface->jbig2_global);
  for (i = 0; i < size; i++) {
global = (cairo_pdf_jbig2_global_t *) _cairo_array_index (&surface->jbig2_global, i);
free(global->id);
if (!global->emitted)
   return _cairo_error (CAIRO_STATUS_JBIG2_GLOBAL_MISSING);
  }
  _cairo_array_fini (&surface->jbig2_global);

  size = _cairo_array_num_elements (&surface->page_labels);
  for (i = 0; i < size; i++) {
_cairo_array_copy_element (&surface->page_labels, i, &label);
free (label);
  }
  _cairo_array_fini (&surface->page_labels);

  _cairo_surface_clipper_reset (&surface->clipper);

  _cairo_pdf_interchange_fini (surface);

  return status;
2862}

2864static cairo_int_status_t
2865_cairo_pdf_surface_start_page (void *abstract_surface)
2866{
  cairo_pdf_surface_t *surface = abstract_surface;
  cairo_pdf_page_info_t page_info;
  cairo_int_status_t status;

  /* Document header */
  if (! surface->header_emitted) {
const char *version;

switch (surface->pdf_version) {
case CAIRO_PDF_VERSION_1_4:
   version = "1.4";
   break;
case CAIRO_PDF_VERSION_1_5:
   version = "1.5";
   break;
case CAIRO_PDF_VERSION_1_6:
   version = "1.6";
   break;
default:
case CAIRO_PDF_VERSION_1_7:
   version = "1.7";
   break;
}

_cairo_output_stream_printf (surface->output,
		     "%%PDF-%s\n", version);
_cairo_output_stream_printf (surface->output,
		     "%%%c%c%c%c\n", 181, 237, 174, 251);
surface->header_emitted = TRUE1;
  }

  _cairo_pdf_group_resources_clear (&surface->resources);
  surface->in_xobject = FALSE0;

  page_info.page_res = _cairo_pdf_surface_new_object (surface);
  if (page_info.page_res.id == 0)
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  page_info.width = surface->width;
  page_info.height = surface->height;
  page_info.content.id = 0;
  page_info.resources.id = 0;
  page_info.thumbnail.id = 0;
  page_info.struct_parents = -1;
  _cairo_array_init (&page_info.annots, sizeof (cairo_pdf_resource_t));

  status = _cairo_array_append (&surface->pages, &page_info);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  return CAIRO_STATUS_SUCCESS;
2918}

2920static cairo_int_status_t
2921_cairo_pdf_surface_has_fallback_images (void		*abstract_surface,
			cairo_bool_t	 has_fallbacks)
2923{
  cairo_int_status_t status;
  cairo_pdf_surface_t *surface = abstract_surface;
  cairo_box_double_t bbox;

  status = _cairo_pdf_interchange_end_page_content (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  surface->has_fallback_images = has_fallbacks;
  surface->in_xobject = has_fallbacks;
  bbox.p1.x = 0;
  bbox.p1.y = 0;
  bbox.p2.x = surface->width;
  bbox.p2.y = surface->height;
  status = _cairo_pdf_surface_open_content_stream (surface, &bbox, NULL((void*)0), has_fallbacks, has_fallbacks, -1);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  return CAIRO_STATUS_SUCCESS;
2943}

2945static cairo_bool_t
2946_cairo_pdf_surface_supports_fine_grained_fallbacks (void *abstract_surface)
2947{
  return TRUE1;
2949}

2951static cairo_bool_t
2952_cairo_pdf_surface_requires_thumbnail_image (void *abstract_surface,
			     int  *width,
			     int  *height)
2955{
  cairo_pdf_surface_t *surface = abstract_surface;

  if (surface->thumbnail_width > 0 && surface->thumbnail_height > 0) {
*width = surface->thumbnail_width;
*height = surface->thumbnail_height;
return TRUE1;
  }

  return FALSE0;
2965}

2967static cairo_int_status_t
2968_cairo_pdf_surface_set_thumbnail_image (void                  *abstract_surface,
			cairo_image_surface_t *image)
2970{
  cairo_pdf_surface_t *surface = abstract_surface;

  surface->thumbnail_image = 	(cairo_image_surface_t *)cairo_surface_reference_moz_cairo_surface_reference(&image->base);

  return CAIRO_STATUS_SUCCESS;
2976}

2978static cairo_int_status_t
2979_cairo_pdf_surface_add_padded_image_surface (cairo_pdf_surface_t          *surface,
			     const cairo_pattern_t        *source,
			     const cairo_rectangle_int_t  *extents,
			     cairo_pdf_source_surface_entry_t **pdf_source,
			     double                       *x_offset,
			     double                       *y_offset,
			     cairo_rectangle_int_t        *source_extents)
2986{
  cairo_image_surface_t *image;
  cairo_surface_t *pad_image;
  void *image_extra;
  cairo_int_status_t status;
  int w, h;
  cairo_box_t box;
  cairo_rectangle_int_t rect;
  cairo_surface_pattern_t pad_pattern;

  status = _cairo_pdf_surface_acquire_source_image_from_pattern (surface, source,
						   &image, &image_extra);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
      return status;

  pad_image = &image->base;

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

  /* Check if image needs padding to fill extents */
  w = image->width;
  h = image->height;
  if (_cairo_fixed_integer_ceil(box.p1.x) < 0 ||
_cairo_fixed_integer_ceil(box.p1.y) < 0 ||
_cairo_fixed_integer_floor(box.p2.x) > w ||
_cairo_fixed_integer_floor(box.p2.y) > h)
  {
pad_image = _cairo_image_surface_create_with_content (image->base.content,
					      rect.width,
					      rect.height);
if (pad_image->status) {
   status = pad_image->status;
   goto BAIL;
}

_cairo_pattern_init_for_surface (&pad_pattern, &image->base);
cairo_matrix_init_translate_moz_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((void*)0));
      _cairo_pattern_fini (&pad_pattern.base);
      if (unlikely (status)(__builtin_expect (!!(status), 0)))
          goto BAIL;
  }

  status = _cairo_pdf_surface_add_source_surface (surface,
				    pad_image,
				    NULL((void*)0),
				    -1 , /* node_surface_index */
				    CAIRO_OPERATOR_OVER, /* not used for images */
				    source->filter,
				    FALSE0, /* stencil mask */
				    FALSE0, /* smask */
				    FALSE0, /* need_transp_group */
				    extents,
				    NULL((void*)0), /* smask_res */
				    pdf_source,
				    x_offset,
				    y_offset,
				    source_extents);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
      goto BAIL;

  if (pad_image != &image->base) {
/* If using a padded image, replace _add_source_surface
* x/y_offset with padded image offset. Note:
* _add_source_surface only sets a non zero x/y_offset for
* RASTER_SOURCE patterns. _add_source_surface will always set
* x/y_offset to 0 for surfaces so we can ignore the returned
* offset and replace it with the offset required for the
* padded image */
*x_offset = rect.x;
*y_offset = rect.y;
  }

3065BAIL:
  if (pad_image != &image->base)
      cairo_surface_destroy_moz_cairo_surface_destroy (pad_image);

  _cairo_pdf_surface_release_source_image_from_pattern (surface, source, image, image_extra);

  return status;
3072}

3074/* Emit alpha channel from the image into stream_res.
*/
3076static cairo_int_status_t
3077_cairo_pdf_surface_emit_smask (cairo_pdf_surface_t	*surface,
	       cairo_image_surface_t	*image,
	       cairo_bool_t              stencil_mask,
	       cairo_bool_t              interpolate,
	       cairo_pdf_resource_t	*stream_res)
3082{
  cairo_int_status_t status = CAIRO_STATUS_SUCCESS;
  char *alpha;
  unsigned long alpha_size;
  uint32_t *pixel32;
  uint8_t *pixel8;
  unsigned long i;
  int x, y, bit, a;
  cairo_image_transparency_t transparency;

  /* This is the only image format we support, which simplifies things. */
  assert (image->format == CAIRO_FORMAT_ARGB32 ||((void) sizeof (__assert_single_arg (image->format == CAIRO_FORMAT_ARGB32
 || image->format == CAIRO_FORMAT_RGB24 || image->format
 == CAIRO_FORMAT_A8 || image->format == CAIRO_FORMAT_A1)),
 __extension__ ({ if (image->format == CAIRO_FORMAT_ARGB32
 || image->format == CAIRO_FORMAT_RGB24 || image->format
 == CAIRO_FORMAT_A8 || image->format == CAIRO_FORMAT_A1) ;
 else __assert_fail ("image->format == CAIRO_FORMAT_ARGB32 || image->format == CAIRO_FORMAT_RGB24 || image->format == CAIRO_FORMAT_A8 || image->format == CAIRO_FORMAT_A1"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 3096, __extension__ __PRETTY_FUNCTION__); }))
   image->format == CAIRO_FORMAT_RGB24 ||((void) sizeof (__assert_single_arg (image->format == CAIRO_FORMAT_ARGB32
 || image->format == CAIRO_FORMAT_RGB24 || image->format
 == CAIRO_FORMAT_A8 || image->format == CAIRO_FORMAT_A1)),
 __extension__ ({ if (image->format == CAIRO_FORMAT_ARGB32
 || image->format == CAIRO_FORMAT_RGB24 || image->format
 == CAIRO_FORMAT_A8 || image->format == CAIRO_FORMAT_A1) ;
 else __assert_fail ("image->format == CAIRO_FORMAT_ARGB32 || image->format == CAIRO_FORMAT_RGB24 || image->format == CAIRO_FORMAT_A8 || image->format == CAIRO_FORMAT_A1"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 3096, __extension__ __PRETTY_FUNCTION__); }))
   image->format == CAIRO_FORMAT_A8 ||((void) sizeof (__assert_single_arg (image->format == CAIRO_FORMAT_ARGB32
 || image->format == CAIRO_FORMAT_RGB24 || image->format
 == CAIRO_FORMAT_A8 || image->format == CAIRO_FORMAT_A1)),
 __extension__ ({ if (image->format == CAIRO_FORMAT_ARGB32
 || image->format == CAIRO_FORMAT_RGB24 || image->format
 == CAIRO_FORMAT_A8 || image->format == CAIRO_FORMAT_A1) ;
 else __assert_fail ("image->format == CAIRO_FORMAT_ARGB32 || image->format == CAIRO_FORMAT_RGB24 || image->format == CAIRO_FORMAT_A8 || image->format == CAIRO_FORMAT_A1"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 3096, __extension__ __PRETTY_FUNCTION__); }))
   image->format == CAIRO_FORMAT_A1 )((void) sizeof (__assert_single_arg (image->format == CAIRO_FORMAT_ARGB32
 || image->format == CAIRO_FORMAT_RGB24 || image->format
 == CAIRO_FORMAT_A8 || image->format == CAIRO_FORMAT_A1)),
 __extension__ ({ if (image->format == CAIRO_FORMAT_ARGB32
 || image->format == CAIRO_FORMAT_RGB24 || image->format
 == CAIRO_FORMAT_A8 || image->format == CAIRO_FORMAT_A1) ;
 else __assert_fail ("image->format == CAIRO_FORMAT_ARGB32 || image->format == CAIRO_FORMAT_RGB24 || image->format == CAIRO_FORMAT_A8 || image->format == CAIRO_FORMAT_A1"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 3096, __extension__ __PRETTY_FUNCTION__); }));

  transparency = _cairo_image_analyze_transparency (image);
  if (stencil_mask) {
assert (transparency == CAIRO_IMAGE_IS_OPAQUE ||((void) sizeof (__assert_single_arg (transparency == CAIRO_IMAGE_IS_OPAQUE
 || transparency == CAIRO_IMAGE_HAS_BILEVEL_ALPHA)), __extension__
 ({ if (transparency == CAIRO_IMAGE_IS_OPAQUE || transparency
 == CAIRO_IMAGE_HAS_BILEVEL_ALPHA) ; else __assert_fail ("transparency == CAIRO_IMAGE_IS_OPAQUE || transparency == CAIRO_IMAGE_HAS_BILEVEL_ALPHA"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 3101, __extension__ __PRETTY_FUNCTION__); }))
transparency == CAIRO_IMAGE_HAS_BILEVEL_ALPHA)((void) sizeof (__assert_single_arg (transparency == CAIRO_IMAGE_IS_OPAQUE
 || transparency == CAIRO_IMAGE_HAS_BILEVEL_ALPHA)), __extension__
 ({ if (transparency == CAIRO_IMAGE_IS_OPAQUE || transparency
 == CAIRO_IMAGE_HAS_BILEVEL_ALPHA) ; else __assert_fail ("transparency == CAIRO_IMAGE_IS_OPAQUE || transparency == CAIRO_IMAGE_HAS_BILEVEL_ALPHA"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 3101, __extension__ __PRETTY_FUNCTION__); }));
  } else {
assert (transparency != CAIRO_IMAGE_IS_OPAQUE)((void) sizeof (__assert_single_arg (transparency != CAIRO_IMAGE_IS_OPAQUE
)), __extension__ ({ if (transparency != CAIRO_IMAGE_IS_OPAQUE
) ; else __assert_fail ("transparency != CAIRO_IMAGE_IS_OPAQUE"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 3103, __extension__ __PRETTY_FUNCTION__); }));
  }

  if (transparency == CAIRO_IMAGE_HAS_BILEVEL_ALPHA || transparency == CAIRO_IMAGE_IS_OPAQUE) {
alpha_size = (unsigned long) ((image->width + 7) / 8) * image->height;
alpha = _cairo_malloc_ab ((image->width+7) / 8, image->height);
  } else {
alpha_size = (unsigned long) image->height * image->width;
alpha = _cairo_malloc_ab (image->height, image->width);
  }

  if (unlikely (alpha == NULL)(__builtin_expect (!!(alpha == ((void*)0)), 0))) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto CLEANUP;
  }

  i = 0;
  for (y = 0; y < image->height; y++) {
if (transparency == CAIRO_IMAGE_IS_OPAQUE) {
   for (x = 0; x < (image->width + 7) / 8; x++)
alpha[i++] = 0xff;
} else if (image->format == CAIRO_FORMAT_A1) {
   pixel8 = (uint8_t *) (image->data + y * image->stride);

   for (x = 0; x < (image->width + 7) / 8; x++, pixel8++) {
a = *pixel8;
a = CAIRO_BITSWAP8_IF_LITTLE_ENDIAN (a)((((a) * 0x0802LU & 0x22110LU) | ((a) * 0x8020LU & 0x88440LU
)) * 0x10101LU >> 16);
alpha[i++] = a;
   }
} else {
   pixel8 = (uint8_t *) (image->data + y * image->stride);
   pixel32 = (uint32_t *) (image->data + y * image->stride);
   bit = 7;
   for (x = 0; x < image->width; x++) {
if (image->format == CAIRO_FORMAT_ARGB32) {
    a = (*pixel32 & 0xff000000) >> 24;
    pixel32++;
} else {
    a = *pixel8;
    pixel8++;
}

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

  if (stencil_mask) {
status = _cairo_pdf_surface_open_stream (surface,
				 stream_res,
				 TRUE1,
				 "   /Type /XObject\n"
				 "   /Subtype /Image\n"
				 "   /ImageMask true\n"
				 "   /Width %d\n"
				 "   /Height %d\n"
				 "   /Interpolate %s\n"
				 "   /BitsPerComponent 1\n"
				 "   /Decode [1 0]\n",
				 image->width, image->height,
				 interpolate ? "true" : "false");
  } else {
status = _cairo_pdf_surface_open_stream (surface,
				 stream_res,
				 TRUE1,
				 "   /Type /XObject\n"
				 "   /Subtype /Image\n"
				 "   /Width %d\n"
				 "   /Height %d\n"
				 "   /ColorSpace /DeviceGray\n"
				 "   /Interpolate %s\n"
				 "   /BitsPerComponent %d\n",
				 image->width, image->height,
				 interpolate ? "true" : "false",
				 transparency == CAIRO_IMAGE_HAS_ALPHA ? 8 : 1);
  }
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto CLEANUP_ALPHA;

  _cairo_output_stream_write (surface->output, alpha, alpha_size);
  status = _cairo_pdf_surface_close_stream (surface);

CLEANUP_ALPHA:
  free (alpha);
CLEANUP:
  return status;
3203}

3205/**
* _cairo_pdf_surface_emit_image:
* @surface: the pdf surface
* @image_surf: The image to write
* @surface_entry: Contains image resource, smask resource, interpolate and stencil mask parameters.
*
* Emit an image stream using the @image_res resource and write out
* the image data from @image_surf. If @smask_res is not null, @smask_res will
* be specified as the smask for the image. Otherwise emit the an smask if
* the image is requires one.
**/
3216static cairo_int_status_t
3217_cairo_pdf_surface_emit_image (cairo_pdf_surface_t              *surface,
                             cairo_image_surface_t            *image_surf,
	       cairo_pdf_source_surface_entry_t *surface_entry)
3220{
  cairo_int_status_t status = CAIRO_STATUS_SUCCESS;
  char *data;
  unsigned long data_size;
  uint32_t *pixel;
  unsigned long i;
  int x, y, bit;
  cairo_pdf_resource_t smask = {0}; /* squelch bogus compiler warning */
  cairo_bool_t need_smask;
  cairo_image_color_t color;
  cairo_image_surface_t *image;
  cairo_image_transparency_t transparency;
  char smask_buf[30];

  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 CLEANUP;
}

_cairo_pattern_init_for_surface (&pattern, &image_surf->base);
status = _cairo_surface_paint (surf,
		       CAIRO_OPERATOR_SOURCE, &pattern.base,
		       NULL((void*)0));
      _cairo_pattern_fini (&pattern.base);
      if (unlikely (status)(__builtin_expect (!!(status), 0)))
          goto CLEANUP;
  }

  if (surface_entry->smask || surface_entry->stencil_mask) {
return _cairo_pdf_surface_emit_smask (surface, image,
			      surface_entry->stencil_mask,
			      surface_entry->interpolate,
			      &surface_entry->surface_res);
  }

  color = _cairo_image_analyze_color (image);
  switch (color) {
      default:
case CAIRO_IMAGE_UNKNOWN_COLOR:
   ASSERT_NOT_REACHEDdo { ((void) sizeof (__assert_single_arg (!"reached")), __extension__
 ({ if (!"reached") ; else __assert_fail ("!\"reached\"", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 3272, __extension__ __PRETTY_FUNCTION__); })); } while (0);
case CAIRO_IMAGE_IS_COLOR:
   data_size = (unsigned long) image->height * image->width * 3;
   data = _cairo_malloc_abc (image->width, image->height, 3);
   break;

case CAIRO_IMAGE_IS_GRAYSCALE:
   data_size = (unsigned long) image->height * image->width;
   data = _cairo_malloc_ab (image->width, image->height);
   break;
case CAIRO_IMAGE_IS_MONOCHROME:
   data_size = (unsigned long) ((image->width + 7) / 8) * image->height;
   data = _cairo_malloc_ab ((image->width+7) / 8, image->height);
   break;
  }
  if (unlikely (data == NULL)(__builtin_expect (!!(data == ((void*)0)), 0))) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto CLEANUP;
  }

  i = 0;
  for (y = 0; y < image->height; y++) {
pixel = (uint32_t *) (image->data + y * image->stride);

bit = 7;
for (x = 0; x < image->width; x++, pixel++) {
   int r, g, b;

   /* XXX: We're un-premultiplying alpha here. My reading of the PDF
    * specification suggests that we should be able to avoid having
    * to do this by filling in the SMask's Matte dictionary
    * appropriately, but my attempts to do that so far have
    * failed. */
   if (image->format == CAIRO_FORMAT_ARGB32) {
uint8_t a;
a = (*pixel & 0xff000000) >> 24;
if (a == 0) {
    r = g = b = 0;
} else {
    r = (((*pixel & 0xff0000) >> 16) * 255 + a / 2) / a;
    g = (((*pixel & 0x00ff00) >>  8) * 255 + a / 2) / a;
    b = (((*pixel & 0x0000ff) >>  0) * 255 + a / 2) / a;
}
   } else if (image->format == CAIRO_FORMAT_RGB24) {
r = (*pixel & 0x00ff0000) >> 16;
g = (*pixel & 0x0000ff00) >>  8;
b = (*pixel & 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_entry->smask_res.id != 0) {
need_smask = TRUE1;
smask = surface_entry->smask_res;
  } else {
need_smask = FALSE0;
if (image->format == CAIRO_FORMAT_ARGB32 ||
   image->format == CAIRO_FORMAT_A8 ||
   image->format == CAIRO_FORMAT_A1)
{
   transparency = _cairo_image_analyze_transparency (image);
   if (transparency != CAIRO_IMAGE_IS_OPAQUE) {
need_smask = TRUE1;
smask = _cairo_pdf_surface_new_object (surface);
if (smask.id == 0) {
    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
    goto CLEANUP_RGB;
}

status = _cairo_pdf_surface_emit_smask (surface, image, FALSE0, surface_entry->interpolate, &smask);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
    goto CLEANUP_RGB;
   }
}
  }

  if (need_smask)
snprintf(smask_buf, sizeof(smask_buf), "   /SMask %d 0 R\n", smask.id);
  else
smask_buf[0] = 0;

  status = _cairo_pdf_surface_open_stream (surface,
			     &surface_entry->surface_res,
			     TRUE1,
			     "   /Type /XObject\n"
			     "   /Subtype /Image\n"
			     "   /Width %d\n"
			     "   /Height %d\n"
			     "   /ColorSpace %s\n"
			     "   /Interpolate %s\n"
			     "   /BitsPerComponent %d\n"
			     "%s",
			     image->width,
			     image->height,
			     color == CAIRO_IMAGE_IS_COLOR ? "/DeviceRGB" : "/DeviceGray",
			     surface_entry->interpolate ? "true" : "false",
			     color == CAIRO_IMAGE_IS_MONOCHROME? 1 : 8,
			     smask_buf);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto CLEANUP_RGB;

3402#undef IMAGE_DICTIONARY

  _cairo_output_stream_write (surface->output, data, data_size);
  status = _cairo_pdf_surface_close_stream (surface);

3407CLEANUP_RGB:
  free (data);
3409CLEANUP:
  if (image != image_surf)
cairo_surface_destroy_moz_cairo_surface_destroy (&image->base);

  return status;
3414}

3416static cairo_int_status_t
3417_cairo_pdf_surface_lookup_jbig2_global (cairo_pdf_surface_t       *surface,
			const unsigned char       *global_id,
			unsigned long              global_id_length,
			cairo_pdf_jbig2_global_t **entry)
3421{
  cairo_pdf_jbig2_global_t global;
  int size, i;
  cairo_int_status_t status;

  size = _cairo_array_num_elements (&surface->jbig2_global);
  for (i = 0; i < size; i++) {
*entry = (cairo_pdf_jbig2_global_t *) _cairo_array_index (&surface->jbig2_global, i);
if ((*entry)->id && global_id && (*entry)->id_length == global_id_length
   && memcmp((*entry)->id, global_id, global_id_length) == 0) {
   return CAIRO_STATUS_SUCCESS;
}
  }

  global.id = _cairo_malloc (global_id_length)((global_id_length) != 0 ? malloc(global_id_length) : ((void*
)0));
  if (unlikely (global.id == NULL)(__builtin_expect (!!(global.id == ((void*)0)), 0))) {
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
  }

  memcpy (global.id, global_id, global_id_length);
  global.id_length = global_id_length;
  global.res = _cairo_pdf_surface_new_object (surface);
  if (global.res.id == 0) {
free(global.id);
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
  }

  global.emitted = FALSE0;
  status = _cairo_array_append (&surface->jbig2_global, &global);
  if (unlikely(status)(__builtin_expect (!!(status), 0)))
return status;

  size = _cairo_array_num_elements (&surface->jbig2_global);
  *entry = (cairo_pdf_jbig2_global_t *) _cairo_array_index (&surface->jbig2_global, size - 1);
  return CAIRO_STATUS_SUCCESS;
3456}

3458static cairo_int_status_t
3459_cairo_pdf_surface_emit_jbig2_image (cairo_pdf_surface_t              *surface,
		     cairo_surface_t	              *source,
		     cairo_pdf_source_surface_entry_t *surface_entry,
		     cairo_bool_t                      test)
3463{
  cairo_int_status_t status;
  const unsigned char *mime_data;
  unsigned long mime_data_length;
  cairo_image_info_t info;
  const unsigned char *global_id;
  unsigned long global_id_length;
  const unsigned char *global_data;
  unsigned long global_data_length;
  cairo_pdf_jbig2_global_t *global_entry = NULL((void*)0); /* hide compiler warning */
  char smask_buf[30];
  char decode_parms_buf[100];

  cairo_surface_get_mime_data_moz_cairo_surface_get_mime_data (source, CAIRO_MIME_TYPE_JBIG2"application/x-cairo.jbig2",
		 &mime_data, &mime_data_length);
  if (mime_data == NULL((void*)0))
return CAIRO_INT_STATUS_UNSUPPORTED;

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

  /* At this point we know emitting jbig2 will succeed. */
  if (test)
return CAIRO_STATUS_SUCCESS;

  cairo_surface_get_mime_data_moz_cairo_surface_get_mime_data (source, CAIRO_MIME_TYPE_JBIG2_GLOBAL_ID"application/x-cairo.jbig2-global-id",
		 &global_id, &global_id_length);
  if (global_id && global_id_length > 0) {
status = _cairo_pdf_surface_lookup_jbig2_global (surface, global_id, global_id_length, &global_entry);
if (unlikely(status)(__builtin_expect (!!(status), 0)))
   return status;

if (!global_entry->emitted) {
   cairo_surface_get_mime_data_moz_cairo_surface_get_mime_data (source, CAIRO_MIME_TYPE_JBIG2_GLOBAL"application/x-cairo.jbig2-global",
			 &global_data, &global_data_length);
   if (global_data) {
status = _cairo_pdf_surface_open_stream (surface, &global_entry->res, FALSE0, NULL((void*)0));
if (unlikely(status)(__builtin_expect (!!(status), 0)))
    return status;

_cairo_output_stream_write (surface->output, global_data, global_data_length);
status = _cairo_pdf_surface_close_stream (surface);
if (unlikely(status)(__builtin_expect (!!(status), 0)))
    return status;

global_entry->emitted = TRUE1;
   }
}

snprintf(decode_parms_buf, sizeof(decode_parms_buf),
 "   /DecodeParms << /JBIG2Globals %d 0 R >>\n", global_entry->res.id);
  } else {
decode_parms_buf[0] = 0;
  }

  if (surface_entry->smask_res.id)
snprintf(smask_buf, sizeof(smask_buf), "   /SMask %d 0 R\n", surface_entry->smask_res.id);
  else
smask_buf[0] = 0;

  if (surface_entry->stencil_mask) {
status = _cairo_pdf_surface_open_stream (surface,
				 &surface_entry->surface_res,
				 FALSE0,
				 "   /Type /XObject\n"
				 "   /Subtype /Image\n"
				 "   /ImageMask true\n"
				 "   /Width %d\n"
				 "   /Height %d\n"
				 "   /Interpolate %s\n"
				 "   /BitsPerComponent 1\n"
				 "   /Decode [1 0]\n"
				 "   /Filter /JPXDecode\n"
				 "%s",
				 info.width,
				 info.height,
				 surface_entry->interpolate ? "true" : "false",
				 decode_parms_buf);
  } else {
status = _cairo_pdf_surface_open_stream (surface,
				 &surface_entry->surface_res,
				 FALSE0,
				 "   /Type /XObject\n"
				 "   /Subtype /Image\n"
				 "   /Width %d\n"
				 "   /Height %d\n"
				 "   /ColorSpace /DeviceGray\n"
				 "   /BitsPerComponent 1\n"
				 "   /Interpolate %s\n"
				 "%s"
				 "   /Filter /JBIG2Decode\n"
				 "%s",
				 info.width,
				 info.height,
				 surface_entry->interpolate ? "true" : "false",
				 smask_buf,
				 decode_parms_buf);
  }
  if (unlikely(status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_output_stream_write (surface->output, mime_data, mime_data_length);
  status = _cairo_pdf_surface_close_stream (surface);

  return status;
3569}

3571static cairo_int_status_t
3572_cairo_pdf_surface_emit_jpx_image (cairo_pdf_surface_t              *surface,
		   cairo_surface_t	            *source,
		   cairo_pdf_source_surface_entry_t *surface_entry,
		   cairo_bool_t                      test)
3576{
  cairo_int_status_t status;
  const unsigned char *mime_data;
  unsigned long mime_data_length;
  cairo_image_info_t info;
  char smask_buf[30];

  if (surface->pdf_version < CAIRO_PDF_VERSION_1_5)
return CAIRO_INT_STATUS_UNSUPPORTED;

  cairo_surface_get_mime_data_moz_cairo_surface_get_mime_data (source, CAIRO_MIME_TYPE_JP2"image/jp2",
		 &mime_data, &mime_data_length);
  if (mime_data == NULL((void*)0))
return CAIRO_INT_STATUS_UNSUPPORTED;

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

  if ((surface_entry->smask || surface_entry->stencil_mask) && info.num_components != 1)
return CAIRO_INT_STATUS_UNSUPPORTED;

  if ((surface_entry->stencil_mask) && info.bits_per_component != 1)
return CAIRO_INT_STATUS_UNSUPPORTED;

  if (surface_entry->smask_res.id)
snprintf(smask_buf, sizeof(smask_buf), "   /SMask %d 0 R\n", surface_entry->smask_res.id);
  else
smask_buf[0] = 0;

  /* At this point we know emitting jpx will succeed. */
  if (test)
return CAIRO_STATUS_SUCCESS;

  if (surface_entry->stencil_mask) {
status = _cairo_pdf_surface_open_stream (surface,
				 &surface_entry->surface_res,
				 FALSE0,
				 "   /Type /XObject\n"
				 "   /Subtype /Image\n"
				 "   /ImageMask true\n"
				 "   /Width %d\n"
				 "   /Height %d\n"
				 "   /Interpolate %s\n"
				 "   /BitsPerComponent 1\n"
				 "   /Decode [1 0]\n"
				 "   /Filter /JPXDecode\n",
				 info.width,
				 info.height,
				 surface_entry->interpolate ? "true" : "false");
  } else {
status = _cairo_pdf_surface_open_stream (surface,
				 &surface_entry->surface_res,
				 FALSE0,
				 "   /Type /XObject\n"
				 "   /Subtype /Image\n"
				 "   /Width %d\n"
				 "   /Height %d\n"
				 "   /Interpolate %s\n"
				 "%s"
				 "   /Filter /JPXDecode\n",
				 info.width,
				 info.height,
				 surface_entry->interpolate ? "true" : "false",
				 smask_buf);
  }
  if (status)
return status;

  _cairo_output_stream_write (surface->output, mime_data, mime_data_length);
  status = _cairo_pdf_surface_close_stream (surface);

  return status;
3649}

3651static cairo_int_status_t
3652_cairo_pdf_surface_emit_jpeg_image (cairo_pdf_surface_t              *surface,
		    cairo_surface_t	             *source,
		    cairo_pdf_source_surface_entry_t *surface_entry,
		    cairo_bool_t                      test)
3656{
  cairo_int_status_t status;
  const unsigned char *mime_data;
  unsigned long mime_data_length;
  cairo_image_info_t info;
  const char *colorspace;
  char smask_buf[30];

  cairo_surface_get_mime_data_moz_cairo_surface_get_mime_data (source, CAIRO_MIME_TYPE_JPEG"image/jpeg",
		 &mime_data, &mime_data_length);
  if (unlikely (source->status)(__builtin_expect (!!(source->status), 0)))
return source->status;
  if (mime_data == NULL((void*)0))
return CAIRO_INT_STATUS_UNSUPPORTED;

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

  if ((surface_entry->smask || surface_entry->stencil_mask) && info.num_components != 1)
return CAIRO_INT_STATUS_UNSUPPORTED;

  if ((surface_entry->stencil_mask) && info.bits_per_component != 1)
return CAIRO_INT_STATUS_UNSUPPORTED;

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

  /* At this point we know emitting jpeg will succeed. */
  if (test)
return CAIRO_STATUS_SUCCESS;

  if (surface_entry->smask_res.id)
snprintf(smask_buf, sizeof(smask_buf), "   /SMask %d 0 R\n", surface_entry->smask_res.id);
  else
smask_buf[0] = 0;

  if (surface_entry->stencil_mask) {
status = _cairo_pdf_surface_open_stream (surface,
				 &surface_entry->surface_res,
				 FALSE0,
				 "   /Type /XObject\n"
				 "   /Subtype /Image\n"
				 "   /ImageMask true\n"
				 "   /Width %d\n"
				 "   /Height %d\n"
				 "   /Interpolate %s\n"
				 "   /BitsPerComponent 1\n"
				 "   /Decode [1 0]\n"
				 "   /Filter /DCTDecode\n",
				 info.width,
				 info.height,
				 surface_entry->interpolate ? "true" : "false");
  } else {
status = _cairo_pdf_surface_open_stream (surface,
				 &surface_entry->surface_res,
				 FALSE0,
				 "   /Type /XObject\n"
				 "   /Subtype /Image\n"
				 "   /Width %d\n"
				 "   /Height %d\n"
				 "   /ColorSpace %s\n"
				 "   /Interpolate %s\n"
				 "   /BitsPerComponent %d\n"
				 "%s"
				 "   /Filter /DCTDecode\n",
				 info.width,
				 info.height,
				 colorspace,
				 surface_entry->interpolate ? "true" : "false",
				 info.bits_per_component,
				 smask_buf);
  }
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_output_stream_write (surface->output, mime_data, mime_data_length);
  status = _cairo_pdf_surface_close_stream (surface);

  return status;
3747}

3749static cairo_int_status_t
3750_cairo_pdf_surface_emit_ccitt_image (cairo_pdf_surface_t              *surface,
		     cairo_surface_t	             *source,
		     cairo_pdf_source_surface_entry_t *surface_entry,
		     cairo_bool_t                      test)
3754{
  cairo_status_t status;
  const unsigned char *ccitt_data;
  unsigned long ccitt_data_len;
  const unsigned char *ccitt_params_string;
  unsigned long ccitt_params_string_len;
  char *params, *p, *end;
  cairo_ccitt_params_t ccitt_params;
  char buf[300];

  cairo_surface_get_mime_data_moz_cairo_surface_get_mime_data (source, CAIRO_MIME_TYPE_CCITT_FAX"image/g3fax",
		 &ccitt_data, &ccitt_data_len);
  if (unlikely (source->status)(__builtin_expect (!!(source->status), 0)))
return source->status;
  if (ccitt_data == NULL((void*)0))
return CAIRO_INT_STATUS_UNSUPPORTED;

  cairo_surface_get_mime_data_moz_cairo_surface_get_mime_data (source, CAIRO_MIME_TYPE_CCITT_FAX_PARAMS"application/x-cairo.ccitt.params",
		 &ccitt_params_string, &ccitt_params_string_len);
  if (unlikely (source->status)(__builtin_expect (!!(source->status), 0)))
return source->status;
  if (ccitt_params_string == NULL((void*)0))
return CAIRO_INT_STATUS_UNSUPPORTED;

  /* ensure params_string is null terminated */
  params = _cairo_strndupstrndup ((const char *)ccitt_params_string, ccitt_params_string_len);
  if (unlikely (params == NULL)(__builtin_expect (!!(params == ((void*)0)), 0)))
return _cairo_surface_set_error (&surface->base, CAIRO_STATUS_NO_MEMORY);

  status = _cairo_tag_parse_ccitt_params (params, &ccitt_params);
  if (unlikely(status)(__builtin_expect (!!(status), 0)))
return source->status;

  free (params);

  /* At this point we know emitting jbig2 will succeed. */
  if (test)
return CAIRO_STATUS_SUCCESS;

  p = buf;
  *p = 0;
  end = buf + sizeof(buf) - 1;
  p += snprintf (p, end - p, "/Columns %d /Rows %d /K %d",
		 ccitt_params.columns,
		 ccitt_params.rows,
		 ccitt_params.k);
  if (ccitt_params.end_of_line)
p += snprintf (p, end - p, " /EndOfLine true");

  if (ccitt_params.encoded_byte_align)
p += snprintf (p, end - p, " /EncodedByteAlign true");

  if (!ccitt_params.end_of_block)
p += snprintf (p, end - p, " /EndOfBlock false");

  if (ccitt_params.black_is_1)
p += snprintf (p, end - p, " /BlackIs1 true");

  if (ccitt_params.damaged_rows_before_error > 0) {
p += snprintf (p, end - p, " /DamagedRowsBeforeError %d",
       ccitt_params.damaged_rows_before_error);
  }

  if (surface_entry->stencil_mask) {
status = _cairo_pdf_surface_open_stream (surface,
				 &surface_entry->surface_res,
				 FALSE0,
				 "   /Type /XObject\n"
				 "   /Subtype /Image\n"
				 "   /ImageMask true\n"
				 "   /Width %d\n"
				 "   /Height %d\n"
				 "   /Interpolate %s\n"
				 "   /BitsPerComponent 1\n"
				 "   /Decode [1 0]\n"
				 "   /Filter /CCITTFaxDecode\n"
				 "   /DecodeParms << %s >> ",
				 ccitt_params.columns,
				 ccitt_params.rows,
				 surface_entry->interpolate ? "true" : "false",
				 buf);
  } else {
status = _cairo_pdf_surface_open_stream (surface,
				 &surface_entry->surface_res,
				 FALSE0,
				 "   /Type /XObject\n"
				 "   /Subtype /Image\n"
				 "   /Width %d\n"
				 "   /Height %d\n"
				 "   /ColorSpace /DeviceGray\n"
				 "   /BitsPerComponent 1\n"
				 "   /Interpolate %s\n"
				 "   /Filter /CCITTFaxDecode\n"
				 "   /DecodeParms << %s >> ",
				 ccitt_params.columns,
				 ccitt_params.rows,
				 surface_entry->interpolate ? "true" : "false",
				 buf);
  }
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_output_stream_write (surface->output, ccitt_data, ccitt_data_len);
  status = _cairo_pdf_surface_close_stream (surface);

  return status;
3860}

3862static cairo_int_status_t
3863_cairo_pdf_surface_emit_recording_surface (cairo_pdf_surface_t        *surface,
			   cairo_pdf_source_surface_t *pdf_source)
3865{
  cairo_rectangle_int_t old_surface_extents;
  cairo_bool_t old_surface_bounded;
  cairo_paginated_mode_t old_paginated_mode;
  cairo_surface_clipper_t old_clipper;
  cairo_bool_t old_in_xobject;
  cairo_box_double_t bbox;
  cairo_int_status_t status;
  int alpha = 0;
  cairo_surface_t *free_me = NULL((void*)0);
  cairo_surface_t *source;
  const cairo_rectangle_int_t *extents;
  cairo_bool_t is_subsurface;
  cairo_bool_t transparency_group;
  cairo_recording_surface_t *recording;
  int struct_parents = -1;

  assert (pdf_source->type == CAIRO_PATTERN_TYPE_SURFACE)((void) sizeof (__assert_single_arg (pdf_source->type == CAIRO_PATTERN_TYPE_SURFACE
)), __extension__ ({ if (pdf_source->type == CAIRO_PATTERN_TYPE_SURFACE
) ; else __assert_fail ("pdf_source->type == CAIRO_PATTERN_TYPE_SURFACE"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 3882, __extension__ __PRETTY_FUNCTION__); }));

  if (pdf_source->hash_entry->bounded) {
extents = &pdf_source->hash_entry->extents;
  } else {
extents = &pdf_source->hash_entry->required_extents;
  }

  is_subsurface = FALSE0;
  source = pdf_source->surface;
  if (_cairo_surface_is_snapshot (source))
free_me = source = _cairo_surface_snapshot_get_target (source);

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

source = sub->target;
extents = &sub->extents;
is_subsurface = TRUE1;
  }

  assert (source->type == CAIRO_SURFACE_TYPE_RECORDING)((void) sizeof (__assert_single_arg (source->type == CAIRO_SURFACE_TYPE_RECORDING
)), __extension__ ({ if (source->type == CAIRO_SURFACE_TYPE_RECORDING
) ; else __assert_fail ("source->type == CAIRO_SURFACE_TYPE_RECORDING"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 3903, __extension__ __PRETTY_FUNCTION__); }));
  recording = (cairo_recording_surface_t *) source;

  old_in_xobject = surface->in_xobject;
  old_surface_extents = surface->surface_extents;
  old_surface_bounded = surface->surface_bounded;
  old_paginated_mode = surface->paginated_mode;
  old_clipper = surface->clipper;
  surface->surface_extents = *extents;
  _cairo_surface_clipper_init (&surface->clipper,
		 _cairo_pdf_surface_clipper_intersect_clip_path);

  _cairo_pdf_operators_reset (&surface->pdf_operators);
  surface->in_xobject = TRUE1;
  surface->surface_extents = *extents;
  surface->surface_bounded = TRUE1;

  /* Patterns are emitted after fallback images. The paginated mode
   * needs to be set to _RENDER while the recording surface is replayed
   * back to this surface.
   */
  surface->paginated_mode = CAIRO_PAGINATED_MODE_RENDER;
  _cairo_pdf_group_resources_clear (&surface->resources);
  _get_bbox_from_extents (extents, &bbox);

  /* We can optimize away the transparency group allowing the viewer
   * to replay the group in place when:
   *  - ca/CA when painting this groups is 1.0 (need_transp_group is FALSE),
   *  - all operators are OVER, and
   *  - the recording contains only opaque and/or clear alpha.
   */
  transparency_group = pdf_source->hash_entry->need_transp_group ||
!(pdf_source->hash_entry->operator == CAIRO_OPERATOR_OVER &&
	   _cairo_recording_surface_has_only_bilevel_alpha (recording) &&
	   _cairo_recording_surface_has_only_op_over (recording));

  status = _cairo_pdf_interchange_emit_recording_surface_begin (surface,
						  pdf_source->surface,
						  pdf_source->hash_entry->region_id,
						  pdf_source->hash_entry->surface_res,
						  &struct_parents);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto err;

  status = _cairo_pdf_surface_open_content_stream (surface,
				     &bbox,
				     &pdf_source->hash_entry->surface_res,
				     TRUE1,
				     transparency_group,
				     struct_parents);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto err;

  /* Reset gstate */
  surface->reset_gs_required = TRUE1;

  if (source->content == CAIRO_CONTENT_COLOR) {
status = _cairo_pdf_surface_add_alpha (surface, 1.0, &alpha);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto err;

_cairo_output_stream_printf (surface->output,
		     "q /a%d gs 0 0 0 rg %d %d %d %d re f Q\n",
		     alpha,
		     extents->x,
		     extents->y,
		     extents->width,
		     extents->height);
  }

  status = _cairo_recording_surface_replay_region (source,
				     pdf_source->region_id,
				     is_subsurface ? extents : NULL((void*)0),
				     &surface->base,
				     CAIRO_RECORDING_REGION_NATIVE);
  assert (status != CAIRO_INT_STATUS_UNSUPPORTED)((void) sizeof (__assert_single_arg (status != CAIRO_INT_STATUS_UNSUPPORTED
)), __extension__ ({ if (status != CAIRO_INT_STATUS_UNSUPPORTED
) ; else __assert_fail ("status != CAIRO_INT_STATUS_UNSUPPORTED"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 3978, __extension__ __PRETTY_FUNCTION__); }));
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto err;

  status = _cairo_pdf_surface_close_content_stream (surface, TRUE1);

  _cairo_surface_clipper_reset (&surface->clipper);
  surface->clipper = old_clipper;
  _cairo_pdf_operators_reset (&surface->pdf_operators);
  surface->in_xobject = old_in_xobject;
  surface->paginated_mode = old_paginated_mode;
  surface->surface_extents = old_surface_extents;
  surface->surface_bounded = old_surface_bounded;
  surface->reset_gs_required = FALSE0;

  if (pdf_source->hash_entry->region_id > 0)
status = _cairo_pdf_interchange_emit_recording_surface_end (surface, pdf_source->surface);

3996err:
  cairo_surface_destroy_moz_cairo_surface_destroy (free_me);
  return status;
3999}

4001/**
* _cairo_pdf_surface_emit_surface:
* @surface: [in] the pdf surface
* @source: [in] #cairo_pdf_source_surface_t containing the surface to write
* @test: [in] if true, test what type of surface will be emitted.
* @is_image: [out] if @test is true, returns TRUE if the surface will be emitted
*  as an Image XObject.
*
* If @test is FALSE, emit @src_surface as an XObject.
* If @test is TRUE, don't emit anything. Set @is_image based on the output that would be emitted.
**/
4012static cairo_int_status_t
4013_cairo_pdf_surface_emit_surface (cairo_pdf_surface_t        *surface,
		 cairo_pdf_source_surface_t *source,
		 cairo_bool_t                test,
		 cairo_bool_t               *is_image)
4017{
  cairo_image_surface_t *image;
  void *image_extra;
  cairo_int_status_t status;

  /* Try all the supported mime types and recording type, falling through
   * each option if unsupported */
  if (source->type == CAIRO_PATTERN_TYPE_SURFACE) {
status = _cairo_pdf_surface_emit_jbig2_image (surface,
				      source->surface,
				      source->hash_entry,
				      test);
if (status != CAIRO_INT_STATUS_UNSUPPORTED) {
   *is_image = TRUE1;
   return status;
}

status = _cairo_pdf_surface_emit_jpx_image (surface,
				    source->surface,
				    source->hash_entry,
				    test);
if (status != CAIRO_INT_STATUS_UNSUPPORTED) {
   *is_image = TRUE1;
   return status;
}

status = _cairo_pdf_surface_emit_jpeg_image (surface,
				     source->surface,
				     source->hash_entry,
				     test);
if (status != CAIRO_INT_STATUS_UNSUPPORTED) {
   *is_image = TRUE1;
   return status;
}

status = _cairo_pdf_surface_emit_ccitt_image (surface,
				      source->surface,
				      source->hash_entry,
				      test);
if (status != CAIRO_INT_STATUS_UNSUPPORTED) {
   *is_image = TRUE1;
   return status;
}

if (source->surface->type == CAIRO_SURFACE_TYPE_RECORDING) {
   if (test) {
*is_image = FALSE0;
return CAIRO_INT_STATUS_SUCCESS;
   } else {
return _cairo_pdf_surface_emit_recording_surface (surface, source);
   }
}
  }

  /* The only option left is to emit as an image surface */

  if (source->type == CAIRO_PATTERN_TYPE_SURFACE) {
status = _cairo_surface_acquire_source_image (source->surface, &image, &image_extra);
  } else {
status = _cairo_pdf_surface_acquire_source_image_from_pattern (surface,
						       source->raster_pattern,
						       &image,
						       &image_extra);
  }
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (test) {
*is_image = TRUE1;
  } else {
status = _cairo_pdf_surface_emit_image (surface,
				image,
				source->hash_entry);
  }

  if (source->type == CAIRO_PATTERN_TYPE_SURFACE) {
_cairo_surface_release_source_image (source->surface, image, image_extra);
  } else {
_cairo_pdf_surface_release_source_image_from_pattern (surface,
					      source->raster_pattern,
					      image,
					      image_extra);
  }

  return status;
4102}

4104static cairo_int_status_t
4105_cairo_pdf_surface_emit_surface_pattern (cairo_pdf_surface_t	*surface,
			 cairo_pdf_pattern_t	*pdf_pattern)
4107{
  cairo_pattern_t *pattern = pdf_pattern->pattern;
  cairo_int_status_t status;
  cairo_matrix_t cairo_p2d, pdf_p2d;
  cairo_extend_t extend = cairo_pattern_get_extend_moz_cairo_pattern_get_extend (pattern);
  double xstep, ystep;
  cairo_rectangle_int_t pattern_extents;
  double x_offset;
  double y_offset;
  char draw_surface[50];
  char draw_surface2[200];
  cairo_box_double_t bbox;
  cairo_matrix_t mat;
  cairo_pdf_source_surface_entry_t *pdf_source;
  cairo_rectangle_int_t op_extents;

  assert (pattern->type == CAIRO_PATTERN_TYPE_SURFACE)((void) sizeof (__assert_single_arg (pattern->type == CAIRO_PATTERN_TYPE_SURFACE
)), __extension__ ({ if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE
) ; else __assert_fail ("pattern->type == CAIRO_PATTERN_TYPE_SURFACE"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 4123, __extension__ __PRETTY_FUNCTION__); }));
  if (pattern->extend == CAIRO_EXTEND_PAD) {
status = _cairo_pdf_surface_add_padded_image_surface (surface,
					      pattern,
					      &pdf_pattern->extents,
					      &pdf_source,
					      &x_offset,
					      &y_offset,
					      &op_extents);
  } else {
status = _cairo_pdf_surface_add_source_surface (surface,
					NULL((void*)0),
					pattern,
					pdf_pattern->region_id,
					pdf_pattern->operator,
					pattern->filter,
					FALSE0, /* stencil mask */
					FALSE0, /* smask */
					FALSE0, /* need_transp_group */
					&pdf_pattern->extents,
					NULL((void*)0), /* smask_res */
					&pdf_source,
					&x_offset,
					&y_offset,
					&op_extents);
  }
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  pattern_extents = pdf_source->extents;
  if (!pdf_source->bounded)
  {
extend = CAIRO_EXTEND_NONE;
_cairo_rectangle_intersect (&pattern_extents, &op_extents);
  }

  switch (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->surface_extents.width;
double y2 = surface->surface_extents.height;
_cairo_matrix_transform_bounding_box (&pattern->matrix,
			      &x1, &y1, &x2, &y2,
			      NULL((void*)0));

/* 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_extents.width + pattern_extents.height);
  }
  break;
  case CAIRO_EXTEND_REPEAT:
xstep = pattern_extents.width;
ystep = pattern_extents.height;
break;

  case CAIRO_EXTEND_REFLECT:
pattern_extents.width *= 2;
pattern_extents.height *= 2;
xstep = pattern_extents.width;
ystep = pattern_extents.height;
break;

  /* All the rest (if any) should have been analyzed away, so this
   * case should be unreachable. */
  default:
ASSERT_NOT_REACHEDdo { ((void) sizeof (__assert_single_arg (!"reached")), __extension__
 ({ if (!"reached") ; else __assert_fail ("!\"reached\"", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 4205, __extension__ __PRETTY_FUNCTION__); })); } while (0);
xstep = 0;
ystep = 0;
  }

  /* At this point, (that is, within the surface backend interface),
   * the pattern's matrix maps from cairo's device space to cairo's
   * pattern space, (both with their origin at the upper-left, and
   * cairo's pattern space of size width,height).
   *
   * Then, we must emit a PDF pattern object that maps from its own
   * pattern space, (which has a size that we establish in the BBox
   * dictionary entry), to the PDF page's *initial* space, (which
   * does not benefit from the Y-axis flipping matrix that we emit
   * on each page). So the PDF patterns matrix maps from a
   * (width,height) pattern space to a device space with the origin
   * in the lower-left corner.
   *
   * So to handle all of that, we start with an identity matrix for
   * the PDF pattern to device matrix. We translate it up by the
   * image height then flip it in the Y direction, (moving us from
   * the PDF origin to cairo's origin). We then multiply in the
   * inverse of the cairo pattern matrix, (since it maps from device
   * to pattern, while we're setting up pattern to device). Finally,
   * we translate back down by the image height and flip again to
   * end up at the lower-left origin that PDF expects.
   *
   * Additionally, within the stream that paints the pattern itself,
   * we are using a PDF image object that has a size of (1,1) so we
   * have to scale it up by the image width and height to fill our
   * pattern cell.
   */
  cairo_p2d = pattern->matrix;
  status = cairo_matrix_invert_moz_cairo_matrix_invert (&cairo_p2d);
  /* cairo_pattern_set_matrix ensures the matrix is invertible */
  assert (status == CAIRO_INT_STATUS_SUCCESS)((void) sizeof (__assert_single_arg (status == CAIRO_INT_STATUS_SUCCESS
)), __extension__ ({ if (status == CAIRO_INT_STATUS_SUCCESS) ;
 else __assert_fail ("status == CAIRO_INT_STATUS_SUCCESS", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 4240, __extension__ __PRETTY_FUNCTION__); }));

  if (pdf_pattern->inverted_y_axis)
cairo_matrix_init_moz_cairo_matrix_init (&mat, 1, 0, 0, 1, 0, 0);
  else
cairo_matrix_init_moz_cairo_matrix_init (&mat, 1, 0, 0, -1, 0, surface->height);

  cairo_matrix_multiply_moz_cairo_matrix_multiply (&pdf_p2d, &cairo_p2d, &mat);
  cairo_matrix_translate_moz_cairo_matrix_translate (&pdf_p2d, x_offset, y_offset);
  if (pdf_source->emit_image) {
cairo_matrix_translate_moz_cairo_matrix_translate (&pdf_p2d, 0.0, pdf_source->extents.height);
cairo_matrix_scale_moz_cairo_matrix_scale (&pdf_p2d, 1.0, -1.0);
  }

  _get_bbox_from_extents (&pattern_extents, &bbox);
  _cairo_pdf_surface_update_object (surface, pdf_pattern->pattern_res);
  status = _cairo_pdf_surface_open_stream (surface,
		             &pdf_pattern->pattern_res,
			     FALSE0,
			     "   /PatternType 1\n"
			     "   /BBox [ %f %f %f %f ]\n"
			     "   /XStep %f\n"
			     "   /YStep %f\n"
			     "   /TilingType 1\n"
			     "   /PaintType 1\n"
			     "   /Matrix [ %f %f %f %f %f %f ]\n"
			     "   /Resources << /XObject << /x%d %d 0 R >> >>\n",
			     bbox.p1.x, bbox.p1.y, bbox.p2.x, bbox.p2.y,
			     xstep, ystep,
			     pdf_p2d.xx, pdf_p2d.yx,
			     pdf_p2d.xy, pdf_p2d.yy,
			     pdf_p2d.x0, pdf_p2d.y0,
			     pdf_source->surface_res.id,
			     pdf_source->surface_res.id);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (pdf_source->emit_image) {
snprintf(draw_surface,
 sizeof (draw_surface),
 "q %d 0 0 %d 0 0 cm /x%d Do Q",
 pdf_source->extents.width,
 pdf_source->extents.height,
 pdf_source->surface_res.id);
  } else {
snprintf(draw_surface,
 sizeof (draw_surface),
 "/x%d Do",
 pdf_source->surface_res.id);
  }

  if (extend == CAIRO_EXTEND_REFLECT) {
cairo_rectangle_int_t p_extents = pdf_source->extents;
snprintf(draw_surface2,
 sizeof (draw_surface2),
 "%d %d %d %d re W n %s",
 p_extents.x, p_extents.y,
 p_extents.width, p_extents.height,
 draw_surface);

_cairo_output_stream_printf (surface->output, "q %s Q\n", draw_surface2);

cairo_matrix_init_translate_moz_cairo_matrix_init_translate (&mat, p_extents.x, p_extents.y);
cairo_matrix_scale_moz_cairo_matrix_scale (&mat, -1, 1);
cairo_matrix_translate_moz_cairo_matrix_translate (&mat, -2*p_extents.width, 0);
cairo_matrix_translate_moz_cairo_matrix_translate (&mat, -p_extents.x, -p_extents.y);
_cairo_output_stream_printf (surface->output, "q ");
_cairo_output_stream_print_matrix (surface->output, &mat);
_cairo_output_stream_printf (surface->output, " cm %s Q\n", draw_surface2);

cairo_matrix_init_translate_moz_cairo_matrix_init_translate (&mat, p_extents.x, p_extents.y);
cairo_matrix_scale_moz_cairo_matrix_scale (&mat, 1, -1);
cairo_matrix_translate_moz_cairo_matrix_translate (&mat, 0, -2*p_extents.height);
cairo_matrix_translate_moz_cairo_matrix_translate (&mat, -p_extents.x, -p_extents.y);
_cairo_output_stream_printf (surface->output, "q ");
_cairo_output_stream_print_matrix (surface->output, &mat);
_cairo_output_stream_printf (surface->output, " cm %s Q\n", draw_surface2);

cairo_matrix_init_translate_moz_cairo_matrix_init_translate (&mat, p_extents.x, p_extents.y);
cairo_matrix_scale_moz_cairo_matrix_scale (&mat, -1, -1);
cairo_matrix_translate_moz_cairo_matrix_translate (&mat, -2*p_extents.width, -2*p_extents.height);
cairo_matrix_translate_moz_cairo_matrix_translate (&mat, -p_extents.x, -p_extents.y);
_cairo_output_stream_printf (surface->output, "q ");
_cairo_output_stream_print_matrix (surface->output, &mat);
_cairo_output_stream_printf (surface->output, " cm %s Q\n", draw_surface2);
  } else {
_cairo_output_stream_printf (surface->output,
		     " %s \n",
		     draw_surface);
  }

  status = _cairo_pdf_surface_close_stream (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  return _cairo_output_stream_get_status (surface->output);
4336}

4338typedef struct _cairo_pdf_color_stop {
  double offset;
  double color[4];
  cairo_pdf_resource_t resource;
4342} cairo_pdf_color_stop_t;

4344static cairo_int_status_t
4345cairo_pdf_surface_emit_rgb_linear_function (cairo_pdf_surface_t    *surface,
                                          cairo_pdf_color_stop_t *stop1,
                                          cairo_pdf_color_stop_t *stop2,
                                          cairo_pdf_resource_t   *function)
4349{
  int num_elems, i;
  cairo_pdf_rgb_linear_function_t elem;
  cairo_pdf_resource_t res;
  cairo_int_status_t status;

  num_elems = _cairo_array_num_elements (&surface->rgb_linear_functions);
  for (i = 0; i < num_elems; i++) {
_cairo_array_copy_element (&surface->rgb_linear_functions, i, &elem);
      if (memcmp (&elem.color1[0], &stop1->color[0], sizeof (double)*3) != 0)
          continue;
      if (memcmp (&elem.color2[0], &stop2->color[0], sizeof (double)*3) != 0)
          continue;
      *function =  elem.resource;
      return CAIRO_STATUS_SUCCESS;
  }

  res = _cairo_pdf_surface_new_object (surface);
  if (res.id == 0)
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /FunctionType 2\n"
		 "   /Domain [ 0 1 ]\n"
		 "   /C0 [ %f %f %f ]\n"
		 "   /C1 [ %f %f %f ]\n"
		 "   /N 1\n"
		 ">>\n"
		 "endobj\n",
		 res.id,
                               stop1->color[0],
                               stop1->color[1],
                               stop1->color[2],
                               stop2->color[0],
                               stop2->color[1],
                               stop2->color[2]);

  elem.resource = res;
  memcpy (&elem.color1[0], &stop1->color[0], sizeof (double)*3);
  memcpy (&elem.color2[0], &stop2->color[0], sizeof (double)*3);

  status = _cairo_array_append (&surface->rgb_linear_functions, &elem);
  *function = res;

  return status;
4395}

4397static cairo_int_status_t
4398cairo_pdf_surface_emit_alpha_linear_function (cairo_pdf_surface_t    *surface,
                                            cairo_pdf_color_stop_t *stop1,
                                            cairo_pdf_color_stop_t *stop2,
                                            cairo_pdf_resource_t   *function)
4402{
  int num_elems, i;
  cairo_pdf_alpha_linear_function_t elem;
  cairo_pdf_resource_t res;
  cairo_int_status_t status;

  num_elems = _cairo_array_num_elements (&surface->alpha_linear_functions);
  for (i = 0; i < num_elems; i++) {
_cairo_array_copy_element (&surface->alpha_linear_functions, i, &elem);
      if (elem.alpha1 != stop1->color[3])
          continue;
      if (elem.alpha2 != stop2->color[3])
          continue;
      *function =  elem.resource;
      return CAIRO_STATUS_SUCCESS;
  }

  res = _cairo_pdf_surface_new_object (surface);
  if (res.id == 0)
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /FunctionType 2\n"
		 "   /Domain [ 0 1 ]\n"
		 "   /C0 [ %f ]\n"
		 "   /C1 [ %f ]\n"
		 "   /N 1\n"
		 ">>\n"
		 "endobj\n",
		 res.id,
                               stop1->color[3],
                               stop2->color[3]);

  elem.resource = res;
  elem.alpha1 = stop1->color[3];
  elem.alpha2 = stop2->color[3];

  status = _cairo_array_append (&surface->alpha_linear_functions, &elem);
  *function = res;

  return status;
4444}

4446static cairo_int_status_t
4447_cairo_pdf_surface_emit_stitched_colorgradient (cairo_pdf_surface_t    *surface,
                                              unsigned int	        n_stops,
                                              cairo_pdf_color_stop_t *stops,
                                              cairo_bool_t	        is_alpha,
                                              cairo_pdf_resource_t   *function)
4452{
  cairo_pdf_resource_t res;
  unsigned int i;
  cairo_int_status_t status;

  /* emit linear gradients between pairs of subsequent stops... */
  for (i = 0; i < n_stops-1; i++) {
      if (is_alpha) {
          status = cairo_pdf_surface_emit_alpha_linear_function (surface,
                                                                 &stops[i],
                                                                 &stops[i+1],
                                                                 &stops[i].resource);
          if (unlikely (status)(__builtin_expect (!!(status), 0)))
              return status;
      } else {
          status = cairo_pdf_surface_emit_rgb_linear_function (surface,
                                                               &stops[i],
                                                               &stops[i+1],
                                                               &stops[i].resource);
          if (unlikely (status)(__builtin_expect (!!(status), 0)))
              return status;
      }
  }

  /* ... and stitch them together */
  res = _cairo_pdf_surface_new_object (surface);
  if (res.id == 0)
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /FunctionType 3\n"
		 "   /Domain [ %f %f ]\n",
		 res.id,
                               stops[0].offset,
                               stops[n_stops - 1].offset);

  _cairo_output_stream_printf (surface->output,
		 "   /Functions [ ");
  for (i = 0; i < n_stops-1; i++)
      _cairo_output_stream_printf (surface->output,
                                   "%d 0 R ", stops[i].resource.id);
  _cairo_output_stream_printf (surface->output,
		 "]\n");

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

  _cairo_output_stream_printf (surface->output,
		 "   /Encode [ ");
  for (i = 1; i < n_stops; i++)
      _cairo_output_stream_printf (surface->output,
		     "0 1 ");
  _cairo_output_stream_printf (surface->output,
		 "]\n");

  _cairo_output_stream_printf (surface->output,
		 ">>\n"
		 "endobj\n");

  *function = res;

  return _cairo_output_stream_get_status (surface->output);
4520}


4523static void
4524calc_gradient_color (cairo_pdf_color_stop_t *new_stop,
     cairo_pdf_color_stop_t *stop1,
     cairo_pdf_color_stop_t *stop2)
4527{
  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]);
4533}

4535#define COLOR_STOP_EPSILON1e-6 1e-6

4537static cairo_int_status_t
4538_cairo_pdf_surface_emit_pattern_stops (cairo_pdf_surface_t      *surface,
                                     cairo_gradient_pattern_t *pattern,
                                     cairo_pdf_resource_t     *color_function,
                                     cairo_pdf_resource_t     *alpha_function)
4542{
  cairo_pdf_color_stop_t *allstops, *stops;
  unsigned int n_stops;
  unsigned int i;
  cairo_bool_t emit_alpha = FALSE0;
  cairo_int_status_t status;

  color_function->id = 0;
  alpha_function->id = 0;

  allstops = _cairo_malloc_ab ((pattern->n_stops + 2), sizeof (cairo_pdf_color_stop_t));
  if (unlikely (allstops == NULL)(__builtin_expect (!!(allstops == ((void*)0)), 0)))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

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

  for (i = 0; i < n_stops; i++) {
stops[i].color[0] = pattern->stops[i].color.red;
stops[i].color[1] = pattern->stops[i].color.green;
stops[i].color[2] = pattern->stops[i].color.blue;
stops[i].color[3] = pattern->stops[i].color.alpha;
      if (!CAIRO_ALPHA_IS_OPAQUE (stops[i].color[3])((stops[i].color[3]) >= ((double)0xff00 / (double)0xffff)))
          emit_alpha = TRUE1;
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_EPSILON1e-6) {
   if (pattern->base.extend == CAIRO_EXTEND_REFLECT)
memcpy (allstops, stops, sizeof (cairo_pdf_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_EPSILON1e-6) {
   if (pattern->base.extend == CAIRO_EXTEND_REFLECT) {
memcpy (&stops[n_stops],
	&stops[n_stops - 1],
	sizeof (cairo_pdf_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;
  }

  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_pdf_color_stop_t pad_stops[4];

assert (pattern->base.extend == CAIRO_EXTEND_PAD)((void) sizeof (__assert_single_arg (pattern->base.extend ==
 CAIRO_EXTEND_PAD)), __extension__ ({ if (pattern->base.extend
 == CAIRO_EXTEND_PAD) ; else __assert_fail ("pattern->base.extend == CAIRO_EXTEND_PAD"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 4612, __extension__ __PRETTY_FUNCTION__); }));

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;

      status = _cairo_pdf_surface_emit_stitched_colorgradient (surface,
                                                               4,
                                                               pad_stops,
                                                               FALSE0,
                                                               color_function);
      if (unlikely (status)(__builtin_expect (!!(status), 0)))
          goto BAIL;

      if (emit_alpha) {
          status = _cairo_pdf_surface_emit_stitched_colorgradient (surface,
                                                                   4,
                                                                   pad_stops,
                                                                   TRUE1,
                                                                   alpha_function);
          if (unlikely (status)(__builtin_expect (!!(status), 0)))
              goto BAIL;
      }
  } else if (n_stops == 2) {
      /* no need for stitched function */
      status = cairo_pdf_surface_emit_rgb_linear_function (surface,
                                                           &stops[0],
                                                           &stops[n_stops - 1],
                                                           color_function);
      if (unlikely (status)(__builtin_expect (!!(status), 0)))
          goto BAIL;

      if (emit_alpha) {
          status = cairo_pdf_surface_emit_alpha_linear_function (surface,
                                                                 &stops[0],
                                                                 &stops[n_stops - 1],
                                                                 alpha_function);
          if (unlikely (status)(__builtin_expect (!!(status), 0)))
              goto BAIL;
      }
  } else {
      /* multiple stops: stitch. XXX possible optimization: regularly spaced
       * stops do not require stitching. XXX */
      status = _cairo_pdf_surface_emit_stitched_colorgradient (surface,
                                                               n_stops,
                                                               stops,
                                                               FALSE0,
                                                               color_function);
      if (unlikely (status)(__builtin_expect (!!(status), 0)))
          goto BAIL;

      if (emit_alpha) {
          status = _cairo_pdf_surface_emit_stitched_colorgradient (surface,
                                                                   n_stops,
                                                                   stops,
                                                                   TRUE1,
                                                                   alpha_function);
          if (unlikely (status)(__builtin_expect (!!(status), 0)))
              goto BAIL;
      }
  }

4676BAIL:
  free (allstops);
  return status;
4679}

4681static cairo_int_status_t
4682_cairo_pdf_surface_emit_repeating_function (cairo_pdf_surface_t      *surface,
			    cairo_gradient_pattern_t *pattern,
			    cairo_pdf_resource_t     *function,
			    int                       begin,
			    int                       end)
4687{
  cairo_pdf_resource_t res;
  int i;

  res = _cairo_pdf_surface_new_object (surface);
  if (res.id == 0)
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /FunctionType 3\n"
		 "   /Domain [ %d %d ]\n",
		 res.id,
                               begin,
                               end);

  _cairo_output_stream_printf (surface->output,
		 "   /Functions [ ");
  for (i = begin; i < end; i++)
      _cairo_output_stream_printf (surface->output,
                                   "%d 0 R ", function->id);
  _cairo_output_stream_printf (surface->output,
		 "]\n");

  _cairo_output_stream_printf (surface->output,
		 "   /Bounds [ ");
  for (i = begin + 1; i < end; i++)
      _cairo_output_stream_printf (surface->output,
		     "%d ", i);
  _cairo_output_stream_printf (surface->output,
		 "]\n");

  _cairo_output_stream_printf (surface->output,
		 "   /Encode [ ");
  for (i = begin; i < end; i++) {
if ((i % 2) && pattern->base.extend == CAIRO_EXTEND_REFLECT) {
   _cairo_output_stream_printf (surface->output,
			 "1 0 ");
} else {
   _cairo_output_stream_printf (surface->output,
			 "0 1 ");
}
  }
  _cairo_output_stream_printf (surface->output,
		 "]\n");

  _cairo_output_stream_printf (surface->output,
		 ">>\n"
		 "endobj\n");

  *function = res;

  return _cairo_output_stream_get_status (surface->output);
4740}

4742static cairo_int_status_t
4743cairo_pdf_surface_emit_transparency_group (cairo_pdf_surface_t  *surface,
			   cairo_pdf_pattern_t  *pdf_pattern,
			   cairo_pdf_resource_t  gstate_resource,
			   cairo_pdf_resource_t  gradient_mask)
4747{
  cairo_pdf_resource_t smask_resource;
  cairo_int_status_t status;
  char buf[100];
  double x1, y1, x2, y2;

  if (pdf_pattern->is_shading) {
snprintf(buf, sizeof(buf),
 "         /Shading\n"
 "            << /sh%d %d 0 R >>\n",
 gradient_mask.id,
 gradient_mask.id);
  } else {
snprintf(buf, sizeof(buf),
 "         /Pattern\n"
 "            << /p%d %d 0 R >>\n",
 gradient_mask.id,
 gradient_mask.id);
  }

  if (pdf_pattern->is_shading) {
cairo_box_t box;

/* When emitting a shading operator we are in cairo pattern
* coordinates. _cairo_pdf_surface_paint_gradient has set the
* ctm to the pattern matrix (including the conversion from
* pdf to cairo coordinates) */
_cairo_box_from_rectangle (&box, &pdf_pattern->extents);
_cairo_box_to_doubles (&box, &x1, &y1, &x2, &y2);
_cairo_matrix_transform_bounding_box (&pdf_pattern->pattern->matrix, &x1, &y1, &x2, &y2, NULL((void*)0));
  } else {
cairo_box_double_t box;

/* When emitting a shading pattern we are in pdf page
* coordinates. The color and alpha shading patterns painted
* in the XObject below contain the cairo pattern to pdf page
* matrix in the /Matrix entry of the pattern. */
_get_bbox_from_extents (&pdf_pattern->extents, &box);
x1 = box.p1.x;
y1 = box.p1.y;
x2 = box.p2.x;
y2 = box.p2.y;
  }
  status = _cairo_pdf_surface_open_stream (surface,
			     NULL((void*)0),
			     surface->compress_streams,
			     "   /Type /XObject\n"
			     "   /Subtype /Form\n"
			     "   /FormType 1\n"
			     "   /BBox [ %f %f %f %f ]\n"
			     "   /Resources\n"
			     "      << /ExtGState\n"
			     "            << /a0 << /ca 1 /CA 1 >>"
			     "      >>\n"
			     "%s"
			     "      >>\n"
			     "   /Group\n"
			     "      << /Type /Group\n"
			     "         /S /Transparency\n"
			     "         /I true\n"
			     "         /CS /DeviceGray\n"
			     "      >>\n",
			     x1,y1,x2,y2,
			     buf);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (pdf_pattern->is_shading) {
_cairo_output_stream_printf (surface->output,
		     "/a0 gs /sh%d sh\n",
		     gradient_mask.id);
  } else {
_cairo_output_stream_printf (surface->output,
		     "q\n"
		     "/a0 gs\n"
		     "/Pattern cs /p%d scn\n"
		     "0 0 %f %f re\n"
		     "f\n"
		     "Q\n",
		     gradient_mask.id,
		     surface->width,
		     surface->height);
  }

  status = _cairo_pdf_surface_close_stream (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  smask_resource = _cairo_pdf_surface_new_object (surface);
  if (smask_resource.id == 0)
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  _cairo_output_stream_printf (surface->output,
                               "%d 0 obj\n"
                               "<< /Type /Mask\n"
                               "   /S /Luminosity\n"
                               "   /G %d 0 R\n"
                               ">>\n"
                               "endobj\n",
                               smask_resource.id,
                               surface->pdf_stream.self.id);

  /* Create GState which uses the transparency group as an SMask. */
  _cairo_pdf_surface_update_object (surface, gstate_resource);

  _cairo_output_stream_printf (surface->output,
                               "%d 0 obj\n"
                               "<< /Type /ExtGState\n"
                               "   /SMask %d 0 R\n"
                               "   /ca 1\n"
                               "   /CA 1\n"
                               "   /AIS false\n"
                               ">>\n"
                               "endobj\n",
                               gstate_resource.id,
                               smask_resource.id);

  return _cairo_output_stream_get_status (surface->output);
4865}

4867static void
4868_cairo_pdf_surface_output_gradient (cairo_pdf_surface_t        *surface,
		    const cairo_pdf_pattern_t  *pdf_pattern,
		    cairo_pdf_resource_t        pattern_resource,
		    const cairo_matrix_t       *pat_to_pdf,
		    const cairo_circle_double_t*start,
		    const cairo_circle_double_t*end,
		    const double               *domain,
		    const char                 *colorspace,
		    cairo_pdf_resource_t        color_function)
4877{
  _cairo_output_stream_printf (surface->output,
                               "%d 0 obj\n",
		 pattern_resource.id);

  if (!pdf_pattern->is_shading) {
_cairo_output_stream_printf (surface->output,
		     "<< /Type /Pattern\n"
		     "   /PatternType 2\n"
		     "   /Matrix [ ");
_cairo_output_stream_print_matrix (surface->output, pat_to_pdf);
_cairo_output_stream_printf (surface->output,
		     " ]\n"
		     "   /Shading\n");
  }

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

  _cairo_output_stream_printf (surface->output,
		 "         /Domain [ %f %f ]\n",
		 domain[0], domain[1]);

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

  _cairo_output_stream_printf (surface->output,
		 "         /Function %d 0 R\n"
                               "      >>\n",
		 color_function.id);

  if (!pdf_pattern->is_shading) {
_cairo_output_stream_printf (surface->output,
		     ">>\n");
  }

  _cairo_output_stream_printf (surface->output,
		     "endobj\n");
4937}

4939static cairo_int_status_t
4940_cairo_pdf_surface_emit_gradient (cairo_pdf_surface_t    *surface,
		  cairo_pdf_pattern_t    *pdf_pattern)
4942{
  cairo_gradient_pattern_t *pattern = (cairo_gradient_pattern_t *) pdf_pattern->pattern;
  cairo_pdf_resource_t color_function, alpha_function;
  cairo_matrix_t pat_to_pdf;
  cairo_circle_double_t start, end;
  double domain[2];
  cairo_int_status_t status;
  cairo_matrix_t mat;

  assert (pattern->n_stops != 0)((void) sizeof (__assert_single_arg (pattern->n_stops != 0
)), __extension__ ({ if (pattern->n_stops != 0) ; else __assert_fail
 ("pattern->n_stops != 0", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 4951, __extension__ __PRETTY_FUNCTION__); }));

  status = _cairo_pdf_surface_emit_pattern_stops (surface,
                                                  pattern,
                                                  &color_function,
                                                  &alpha_function);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  pat_to_pdf = pattern->base.matrix;
  status = cairo_matrix_invert_moz_cairo_matrix_invert (&pat_to_pdf);
  /* cairo_pattern_set_matrix ensures the matrix is invertible */
  assert (status == CAIRO_INT_STATUS_SUCCESS)((void) sizeof (__assert_single_arg (status == CAIRO_INT_STATUS_SUCCESS
)), __extension__ ({ if (status == CAIRO_INT_STATUS_SUCCESS) ;
 else __assert_fail ("status == CAIRO_INT_STATUS_SUCCESS", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 4963, __extension__ __PRETTY_FUNCTION__); }));

  if (pdf_pattern->inverted_y_axis)
     cairo_matrix_init_moz_cairo_matrix_init (&mat, 1, 0, 0, 1, 0, 0);
  else
     cairo_matrix_init_moz_cairo_matrix_init (&mat, 1, 0, 0, -1, 0, surface->height);

  cairo_matrix_multiply_moz_cairo_matrix_multiply (&pat_to_pdf, &pat_to_pdf, &mat);

  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((void*)0));

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)((x_scale) < (y_scale) ? (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)((void) sizeof (__assert_single_arg (pattern->base.extend ==
 CAIRO_EXTEND_PAD)), __extension__ ({ if (pattern->base.extend
 == CAIRO_EXTEND_PAD) ; else __assert_fail ("pattern->base.extend == CAIRO_EXTEND_PAD"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 5013, __extension__ __PRETTY_FUNCTION__); }));
  } else {
domain[0] = pattern->stops[0].offset;
domain[1] = pattern->stops[pattern->n_stops - 1].offset;
  }

  /* PDF 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_pdf_surface_emit_repeating_function (surface,
					     pattern,
					     &color_function,
					     repeat_begin,
					     repeat_end);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

if (alpha_function.id != 0) {
   status = _cairo_pdf_surface_emit_repeating_function (surface,
						 pattern,
						 &alpha_function,
						 repeat_begin,
						 repeat_end);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
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;
  }

  _cairo_pdf_surface_update_object (surface, pdf_pattern->pattern_res);
  _cairo_pdf_surface_output_gradient (surface, pdf_pattern,
			pdf_pattern->pattern_res,
			&pat_to_pdf, &start, &end, domain,
			"/DeviceRGB", color_function);

  if (alpha_function.id != 0) {
cairo_pdf_resource_t mask_resource;

assert (pdf_pattern->gstate_res.id != 0)((void) sizeof (__assert_single_arg (pdf_pattern->gstate_res
.id != 0)), __extension__ ({ if (pdf_pattern->gstate_res.id
 != 0) ; else __assert_fail ("pdf_pattern->gstate_res.id != 0"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 5069, __extension__ __PRETTY_FUNCTION__); }));

      /* Create pattern for SMask. */
      mask_resource = _cairo_pdf_surface_new_object (surface);
if (mask_resource.id == 0)
   return _cairo_error (CAIRO_STATUS_NO_MEMORY);

_cairo_pdf_surface_output_gradient (surface, pdf_pattern,
			    mask_resource,
			    &pat_to_pdf, &start, &end, domain,
			    "/DeviceGray", alpha_function);

status = cairo_pdf_surface_emit_transparency_group (surface,
					    pdf_pattern,
				            pdf_pattern->gstate_res,
					    mask_resource);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;
  }

  return _cairo_output_stream_get_status (surface->output);
5090}

5092static cairo_int_status_t
5093_cairo_pdf_surface_emit_mesh_pattern (cairo_pdf_surface_t    *surface,
		      cairo_pdf_pattern_t    *pdf_pattern)
5095{
  cairo_matrix_t pat_to_pdf;
  cairo_int_status_t status;
  cairo_pattern_t *pattern = pdf_pattern->pattern;
  cairo_pdf_shading_t shading;
  int i;
  cairo_pdf_resource_t res;
  cairo_matrix_t mat;

  pat_to_pdf = pattern->matrix;
  status = cairo_matrix_invert_moz_cairo_matrix_invert (&pat_to_pdf);
  /* cairo_pattern_set_matrix ensures the matrix is invertible */
  assert (status == CAIRO_INT_STATUS_SUCCESS)((void) sizeof (__assert_single_arg (status == CAIRO_INT_STATUS_SUCCESS
)), __extension__ ({ if (status == CAIRO_INT_STATUS_SUCCESS) ;
 else __assert_fail ("status == CAIRO_INT_STATUS_SUCCESS", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 5107, __extension__ __PRETTY_FUNCTION__); }));

  if (pdf_pattern->inverted_y_axis)
cairo_matrix_init_moz_cairo_matrix_init (&mat, 1, 0, 0, 1, 0, 0);
  else
cairo_matrix_init_moz_cairo_matrix_init (&mat, 1, 0, 0, -1, 0, surface->height);

  cairo_matrix_multiply_moz_cairo_matrix_multiply (&pat_to_pdf, &pat_to_pdf, &mat);

  status = _cairo_pdf_shading_init_color (&shading, (cairo_mesh_pattern_t *) pattern);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  res = _cairo_pdf_surface_new_object (surface);
  if (unlikely (res.id == 0)(__builtin_expect (!!(res.id == 0), 0)))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
                               "<< /ShadingType %d\n"
                               "   /ColorSpace /DeviceRGB\n"
		 "   /BitsPerCoordinate %d\n"
		 "   /BitsPerComponent %d\n"
		 "   /BitsPerFlag %d\n"
		 "   /Decode [",
		 res.id,
		 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->output, "%f ", shading.decode_array[i]);

  _cairo_output_stream_printf (surface->output,
		 "]\n"
		 "   /Length %ld\n"
		 ">>\n"
		 "stream\n",
		 shading.data_length);

  _cairo_output_stream_write (surface->output, shading.data, shading.data_length);

  _cairo_output_stream_printf (surface->output,
		 "\nendstream\n"
		 "endobj\n");

  _cairo_pdf_shading_fini (&shading);

  _cairo_pdf_surface_update_object (surface, pdf_pattern->pattern_res);
  _cairo_output_stream_printf (surface->output,
                               "%d 0 obj\n"
                               "<< /Type /Pattern\n"
                               "   /PatternType 2\n"
                               "   /Matrix [ ",
		 pdf_pattern->pattern_res.id);
  _cairo_output_stream_print_matrix (surface->output, &pat_to_pdf);
  _cairo_output_stream_printf (surface->output,
                               " ]\n"
                               "   /Shading %d 0 R\n"
		 ">>\n"
		 "endobj\n",
		 res.id);

  if (pdf_pattern->gstate_res.id != 0) {
cairo_pdf_resource_t mask_resource;

/* Create pattern for SMask. */
      res = _cairo_pdf_surface_new_object (surface);
if (unlikely (res.id == 0)(__builtin_expect (!!(res.id == 0), 0)))
   return _cairo_error (CAIRO_STATUS_NO_MEMORY);

status = _cairo_pdf_shading_init_alpha (&shading, (cairo_mesh_pattern_t *) pattern);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

_cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
                               "<< /ShadingType %d\n"
                               "   /ColorSpace /DeviceGray\n"
		 "   /BitsPerCoordinate %d\n"
		 "   /BitsPerComponent %d\n"
		 "   /BitsPerFlag %d\n"
		 "   /Decode [",
		 res.id,
		 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->output, "%f ", shading.decode_array[i]);

_cairo_output_stream_printf (surface->output,
		     "]\n"
		     "   /Length %ld\n"
		     ">>\n"
		     "stream\n",
		     shading.data_length);

_cairo_output_stream_write (surface->output, shading.data, shading.data_length);

_cairo_output_stream_printf (surface->output,
		     "\nendstream\n"
		     "endobj\n");
_cairo_pdf_shading_fini (&shading);

      mask_resource = _cairo_pdf_surface_new_object (surface);
if (unlikely (mask_resource.id == 0)(__builtin_expect (!!(mask_resource.id == 0), 0)))
   return _cairo_error (CAIRO_STATUS_NO_MEMORY);

_cairo_output_stream_printf (surface->output,
		     "%d 0 obj\n"
		     "<< /Type /Pattern\n"
		     "   /PatternType 2\n"
		     "   /Matrix [ ",
		     mask_resource.id);
_cairo_output_stream_print_matrix (surface->output, &pat_to_pdf);
_cairo_output_stream_printf (surface->output,
		     " ]\n"
		     "   /Shading %d 0 R\n"
		     ">>\n"
		     "endobj\n",
		     res.id);

status = cairo_pdf_surface_emit_transparency_group (surface,
					    pdf_pattern,
				            pdf_pattern->gstate_res,
					    mask_resource);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;
  }

  return _cairo_output_stream_get_status (surface->output);
5241}

5243static cairo_int_status_t
5244_cairo_pdf_surface_emit_pattern (cairo_pdf_surface_t *surface, cairo_pdf_pattern_t *pdf_pattern)
5245{
  cairo_int_status_t status;

  switch (pdf_pattern->pattern->type) {
  case CAIRO_PATTERN_TYPE_SOLID:
ASSERT_NOT_REACHEDdo { ((void) sizeof (__assert_single_arg (!"reached")), __extension__
 ({ if (!"reached") ; else __assert_fail ("!\"reached\"", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 5250, __extension__ __PRETTY_FUNCTION__); })); } while (0);
status = _cairo_error (CAIRO_STATUS_PATTERN_TYPE_MISMATCH);
break;

  case CAIRO_PATTERN_TYPE_SURFACE:
  case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
status = _cairo_pdf_surface_emit_surface_pattern (surface, pdf_pattern);
break;

  case CAIRO_PATTERN_TYPE_LINEAR:
  case CAIRO_PATTERN_TYPE_RADIAL:
status = _cairo_pdf_surface_emit_gradient (surface, pdf_pattern);
break;

  case CAIRO_PATTERN_TYPE_MESH:
status = _cairo_pdf_surface_emit_mesh_pattern (surface, pdf_pattern);
break;

  default:
ASSERT_NOT_REACHEDdo { ((void) sizeof (__assert_single_arg (!"reached")), __extension__
 ({ if (!"reached") ; else __assert_fail ("!\"reached\"", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 5269, __extension__ __PRETTY_FUNCTION__); })); } while (0);
status = _cairo_error (CAIRO_STATUS_PATTERN_TYPE_MISMATCH);
break;
  }

  return status;
5275}

5277static cairo_int_status_t
5278_cairo_pdf_surface_paint_surface_pattern (cairo_pdf_surface_t          *surface,
			  cairo_operator_t              op,
			  const cairo_pattern_t        *source,
			  cairo_analysis_source_t       source_type,
			  const cairo_rectangle_int_t  *extents,
			  double                        alpha,
			  cairo_pdf_resource_t	       *smask_res,
			  cairo_bool_t                  stencil_mask)
5286{
  cairo_matrix_t cairo_p2d, pdf_p2d;
  cairo_int_status_t status;
  int alpha_id;
  double x_offset;
  double y_offset;
  cairo_pdf_source_surface_entry_t *pdf_source;
  int region_id = 0;

  if (source->extend == CAIRO_EXTEND_PAD &&
!(source->type == CAIRO_PATTERN_TYPE_SURFACE &&
 ((cairo_surface_pattern_t *)source)->surface->type == CAIRO_SURFACE_TYPE_RECORDING))
  {
status = _cairo_pdf_surface_add_padded_image_surface (surface,
					      source,
					      extents,
					      &pdf_source,
					      &x_offset,
					      &y_offset,
					      NULL((void*)0));
  } else {
if (source->type == CAIRO_PATTERN_TYPE_SURFACE) {
   cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) source;
   if (_cairo_pdf_interchange_struct_tree_requires_recording_surface (surface,
							       surface_pattern,
							       source_type))
   {
region_id = surface_pattern->region_array_id;
   }
}
status = _cairo_pdf_surface_add_source_surface (surface,
					NULL((void*)0),
					source,
					region_id,
					op,
					source->filter,
					stencil_mask,
					FALSE0, /* smask */
					alpha != 1.0, /* need_transp_group */
					extents,
					smask_res,

					&pdf_source,
					&x_offset,
					&y_offset,
					NULL((void*)0));
  }
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  cairo_p2d = source->matrix;
  status = cairo_matrix_invert_moz_cairo_matrix_invert (&cairo_p2d);
  /* cairo_pattern_set_matrix ensures the matrix is invertible */
  assert (status == CAIRO_INT_STATUS_SUCCESS)((void) sizeof (__assert_single_arg (status == CAIRO_INT_STATUS_SUCCESS
)), __extension__ ({ if (status == CAIRO_INT_STATUS_SUCCESS) ;
 else __assert_fail ("status == CAIRO_INT_STATUS_SUCCESS", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 5339, __extension__ __PRETTY_FUNCTION__); }));

  pdf_p2d = surface->cairo_to_pdf;
  cairo_matrix_multiply_moz_cairo_matrix_multiply (&pdf_p2d, &cairo_p2d, &pdf_p2d);
  cairo_matrix_translate_moz_cairo_matrix_translate (&pdf_p2d, x_offset, y_offset);
  if (pdf_source->emit_image) {
int width, height;

if (pdf_source->bounded) {
   width = pdf_source->extents.width;
   height = pdf_source->extents.height;
} else {
   /* We can't scale an image to an unbounded surface size so just set the size to 1 */
   width = 1;
   height = 1;
}

cairo_matrix_translate_moz_cairo_matrix_translate (&pdf_p2d, 0.0, height);
cairo_matrix_scale_moz_cairo_matrix_scale (&pdf_p2d, 1.0, -1.0);
cairo_matrix_scale_moz_cairo_matrix_scale (&pdf_p2d, width, height);
  }

  status = _cairo_pdf_operators_flush (&surface->pdf_operators);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (! _cairo_matrix_is_identity (&pdf_p2d)) {
_cairo_output_stream_print_matrix (surface->output, &pdf_p2d);
_cairo_output_stream_printf (surface->output, " cm\n");
  }

  status = _cairo_pdf_surface_add_alpha (surface, alpha, &alpha_id);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (stencil_mask) {
_cairo_output_stream_printf (surface->output,
		     "/x%d Do\n",
		     pdf_source->surface_res.id);
  } else {
_cairo_output_stream_printf (surface->output,
		     "/a%d gs /x%d Do\n",
		     alpha_id,
		     pdf_source->surface_res.id);
  }

  return _cairo_pdf_surface_add_xobject (surface, pdf_source->surface_res);
5386}

5388static cairo_int_status_t
5389_cairo_pdf_surface_paint_gradient (cairo_pdf_surface_t         *surface,
		   cairo_operator_t             op,
		   const cairo_pattern_t       *source,
		   const cairo_rectangle_int_t *extents,
		   double                       alpha)
5394{
  cairo_pdf_resource_t shading_res, gstate_res;
  cairo_matrix_t pat_to_pdf;
  cairo_int_status_t status;
  int alpha_id;

  status = _cairo_pdf_surface_add_pdf_shading (surface, source,
				 op, extents,
				 &shading_res, &gstate_res);
  if (unlikely (status == CAIRO_INT_STATUS_NOTHING_TO_DO)(__builtin_expect (!!(status == CAIRO_INT_STATUS_NOTHING_TO_DO
), 0)))
return CAIRO_INT_STATUS_SUCCESS;
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  pat_to_pdf = source->matrix;
  status = cairo_matrix_invert_moz_cairo_matrix_invert (&pat_to_pdf);
  /* cairo_pattern_set_matrix ensures the matrix is invertible */
  assert (status == CAIRO_INT_STATUS_SUCCESS)((void) sizeof (__assert_single_arg (status == CAIRO_INT_STATUS_SUCCESS
)), __extension__ ({ if (status == CAIRO_INT_STATUS_SUCCESS) ;
 else __assert_fail ("status == CAIRO_INT_STATUS_SUCCESS", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 5411, __extension__ __PRETTY_FUNCTION__); }));
  cairo_matrix_multiply_moz_cairo_matrix_multiply (&pat_to_pdf, &pat_to_pdf, &surface->cairo_to_pdf);

  status = _cairo_pdf_operators_flush (&surface->pdf_operators);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (! _cairo_matrix_is_identity (&pat_to_pdf)) {
_cairo_output_stream_print_matrix (surface->output, &pat_to_pdf);
_cairo_output_stream_printf (surface->output, " cm\n");
  }

  status = _cairo_pdf_surface_add_shading (surface, shading_res);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (gstate_res.id != 0) {
status = _cairo_pdf_surface_add_smask (surface, gstate_res);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

_cairo_output_stream_printf (surface->output,
		     "/s%d gs /sh%d sh\n",
		     gstate_res.id,
		     shading_res.id);
  } else {
status = _cairo_pdf_surface_add_alpha (surface, alpha, &alpha_id);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

_cairo_output_stream_printf (surface->output,
		     "/a%d gs /sh%d sh\n",
		     alpha_id,
		     shading_res.id);
  }

  return status;
5448}

5450static cairo_int_status_t
5451_cairo_pdf_surface_paint_pattern (cairo_pdf_surface_t          *surface,
		  cairo_operator_t              op,
		  const cairo_pattern_t        *source,
		  cairo_analysis_source_t       source_type,
		  const cairo_rectangle_int_t  *extents,
		  double                        alpha,
		  cairo_bool_t                  mask)
5458{
  switch (source->type) {
  case CAIRO_PATTERN_TYPE_SURFACE:
  case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
return _cairo_pdf_surface_paint_surface_pattern (surface,
					 op,
					 source,
					 source_type,
					 extents,
					 alpha,
					 NULL((void*)0),
					 mask);
  case CAIRO_PATTERN_TYPE_LINEAR:
  case CAIRO_PATTERN_TYPE_RADIAL:
  case CAIRO_PATTERN_TYPE_MESH:
return _cairo_pdf_surface_paint_gradient (surface,
				  op,
				  source,
				  extents,
				  alpha);

  case CAIRO_PATTERN_TYPE_SOLID:
  default:
ASSERT_NOT_REACHEDdo { ((void) sizeof (__assert_single_arg (!"reached")), __extension__
 ({ if (!"reached") ; else __assert_fail ("!\"reached\"", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 5481, __extension__ __PRETTY_FUNCTION__); })); } while (0);
return CAIRO_STATUS_SUCCESS;
  }
5484}

5486static cairo_bool_t
5487_can_paint_pattern (const cairo_pattern_t *pattern)
5488{
  switch (pattern->type) {
  case CAIRO_PATTERN_TYPE_SOLID:
return FALSE0;

  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:
return TRUE1;

  case CAIRO_PATTERN_TYPE_MESH:
return FALSE0;

  default:
ASSERT_NOT_REACHEDdo { ((void) sizeof (__assert_single_arg (!"reached")), __extension__
 ({ if (!"reached") ; else __assert_fail ("!\"reached\"", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 5506, __extension__ __PRETTY_FUNCTION__); })); } while (0);
return FALSE0;
  }
5509}

5511static cairo_int_status_t
5512_cairo_pdf_surface_select_operator (cairo_pdf_surface_t *surface,
		    cairo_operator_t     op)
5514{
  cairo_int_status_t status;

  if (surface->reset_gs_required) {
_cairo_output_stream_printf (surface->output, "/gs0 gs\n");
surface->reset_gs_required = FALSE0;
  }

  if (op == surface->current_operator)
return CAIRO_STATUS_SUCCESS;

  status = _cairo_pdf_operators_flush (&surface->pdf_operators);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_output_stream_printf (surface->output,
		 "/b%d gs\n", op);
  surface->current_operator = op;
  _cairo_pdf_surface_add_operator (surface, op);

  return CAIRO_STATUS_SUCCESS;
5535}

5537static cairo_int_status_t
5538_cairo_pdf_surface_select_pattern (cairo_pdf_surface_t *surface,
		   const cairo_pattern_t     *pattern,
		   cairo_pdf_resource_t pattern_res,
		   cairo_bool_t         is_stroke)
5542{
  cairo_int_status_t status;
  int alpha;
  const cairo_color_t *solid_color = NULL((void*)0);

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

solid_color = &solid->color;
  }

  if (solid_color != NULL((void*)0)) {
if (surface->current_pattern_is_solid_color == FALSE0 ||
   surface->current_color_red != solid_color->red ||
   surface->current_color_green != solid_color->green ||
   surface->current_color_blue != solid_color->blue ||
   surface->current_color_is_stroke != is_stroke)
{
   status = _cairo_pdf_operators_flush (&surface->pdf_operators);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

   _cairo_output_stream_printf (surface->output,
			 "%f %f %f ",
			 solid_color->red,
			 solid_color->green,
			 solid_color->blue);

   if (is_stroke)
_cairo_output_stream_printf (surface->output, "RG ");
   else
_cairo_output_stream_printf (surface->output, "rg ");

   surface->current_color_red = solid_color->red;
   surface->current_color_green = solid_color->green;
   surface->current_color_blue = solid_color->blue;
   surface->current_color_is_stroke = is_stroke;
}

if (surface->current_pattern_is_solid_color == FALSE0 ||
   surface->current_color_alpha != solid_color->alpha)
{
   status = _cairo_pdf_surface_add_alpha (surface, solid_color->alpha, &alpha);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

   status = _cairo_pdf_operators_flush (&surface->pdf_operators);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

   _cairo_output_stream_printf (surface->output,
			 "/a%d gs\n",
			 alpha);
   surface->current_color_alpha = solid_color->alpha;
}

surface->current_pattern_is_solid_color = TRUE1;
  } else {
status = _cairo_pdf_surface_add_alpha (surface, 1.0, &alpha);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

status = _cairo_pdf_surface_add_pattern (surface, pattern_res);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

status = _cairo_pdf_operators_flush (&surface->pdf_operators);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

/* fill-stroke calls select_pattern twice. Don't save if the
* gstate is already saved. */
if (!surface->select_pattern_gstate_saved)
   _cairo_output_stream_printf (surface->output, "q ");

if (is_stroke) {
   _cairo_output_stream_printf (surface->output,
			 "/Pattern CS /p%d SCN ",
			 pattern_res.id);
} else {
   _cairo_output_stream_printf (surface->output,
			 "/Pattern cs /p%d scn ",
			 pattern_res.id);
}
_cairo_output_stream_printf (surface->output,
		     "/a%d gs\n",
		     alpha);
surface->select_pattern_gstate_saved = TRUE1;
surface->current_pattern_is_solid_color = FALSE0;
  }

  return _cairo_output_stream_get_status (surface->output);
5634}

5636static cairo_int_status_t
5637_cairo_pdf_surface_unselect_pattern (cairo_pdf_surface_t *surface)
5638{
  cairo_int_status_t status;

  if (surface->select_pattern_gstate_saved) {
status = _cairo_pdf_operators_flush (&surface->pdf_operators);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

_cairo_output_stream_printf (surface->output, "Q\n");
_cairo_pdf_operators_reset (&surface->pdf_operators);
surface->current_pattern_is_solid_color = FALSE0;
  }
  surface->select_pattern_gstate_saved = FALSE0;

  return CAIRO_STATUS_SUCCESS;
5653}

5655static cairo_int_status_t
5656_cairo_pdf_surface_show_page (void *abstract_surface)
5657{
  cairo_pdf_surface_t *surface = abstract_surface;
  cairo_int_status_t status;

  status = _cairo_array_append (&surface->page_labels, &surface->current_page_label);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  surface->current_page_label = NULL((void*)0);

  status = _cairo_pdf_interchange_end_page_content (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  status = _cairo_pdf_surface_close_content_stream (surface, FALSE0);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_surface_clipper_reset (&surface->clipper);

  status = _cairo_pdf_surface_write_page (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_pdf_surface_clear (surface, FALSE0);

  return CAIRO_STATUS_SUCCESS;
5684}

5686static cairo_bool_t
5687_cairo_pdf_surface_get_extents (void		        *abstract_surface,
		cairo_rectangle_int_t   *rectangle)
5689{
  cairo_pdf_surface_t *surface = abstract_surface;

  if (surface->surface_bounded)
*rectangle = surface->surface_extents;

  return surface->surface_bounded;
5696}

5698static void
5699_cairo_pdf_surface_get_font_options (void                  *abstract_surface,
		     cairo_font_options_t  *options)
5701{
  _cairo_font_options_init_default (options);

  cairo_font_options_set_hint_style_moz_cairo_font_options_set_hint_style (options, CAIRO_HINT_STYLE_NONE);
  cairo_font_options_set_hint_metrics_moz_cairo_font_options_set_hint_metrics (options, CAIRO_HINT_METRICS_OFF);
  cairo_font_options_set_antialias_moz_cairo_font_options_set_antialias (options, CAIRO_ANTIALIAS_GRAY);
  _cairo_font_options_set_round_glyph_positions (options, CAIRO_ROUND_GLYPH_POS_OFF);
5708}

5710static cairo_int_status_t
5711_cairo_pdf_surface_write_pages (cairo_pdf_surface_t *surface)
5712{
  cairo_pdf_page_info_t *page_info;
  int num_pages, i;
  cairo_int_status_t status;

  status = _cairo_pdf_surface_object_begin (surface, surface->pages_resource);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_output_stream_printf (surface->object_stream.stream,
		 "<< /Type /Pages\n"
		 "   /Kids [ ");

  num_pages = _cairo_array_num_elements (&surface->pages);
  for (i = 0; i < num_pages; i++) {
page_info = _cairo_array_index (&surface->pages, i);
_cairo_output_stream_printf (surface->object_stream.stream, "%d 0 R ", page_info->page_res.id);
  }

  _cairo_output_stream_printf (surface->object_stream.stream, "]\n");
  _cairo_output_stream_printf (surface->object_stream.stream, "   /Count %d\n", num_pages);


  /* TODO: Figure out which other defaults to be inherited by /Page
   * objects. */
  _cairo_output_stream_printf (surface->object_stream.stream,
		 ">>\n");
  _cairo_pdf_surface_object_end (surface);

  return CAIRO_INT_STATUS_SUCCESS;
5742}

5744cairo_int_status_t
5745_cairo_utf8_to_pdf_string (const char *utf8, char **str_out)
5746{
  int i;
  int len;
  unsigned char *p;
  cairo_bool_t ascii;
  char *str;
  cairo_int_status_t status = CAIRO_STATUS_SUCCESS;

  ascii = TRUE1;
  p = (unsigned char *)utf8;
  len = 0;
  while (*p) {
if (*p < 32 || *p > 126) {
   ascii = FALSE0;
   break;
}
if (*p == '(' || *p == ')' || *p == '\\')
   len += 2;
else
   len++;
p++;
  }

  if (ascii) {
str = _cairo_malloc (len + 3)((len + 3) != 0 ? malloc(len + 3) : ((void*)0));
if (str == NULL((void*)0))
   return _cairo_error (CAIRO_STATUS_NO_MEMORY);

str[0] = '(';
p = (unsigned char *)utf8;
i = 1;
while (*p) {
   if (*p == '(' || *p == ')' || *p == '\\')
str[i++] = '\\';
   str[i++] = *p;
   p++;
}
str[i++] = ')';
str[i++] = 0;
  } else {
uint16_t *utf16 = NULL((void*)0);
int utf16_len = 0;

status = _cairo_utf8_to_utf16 (utf8, -1, &utf16, &utf16_len);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

str = _cairo_malloc (utf16_len*4 + 7)((utf16_len*4 + 7) != 0 ? malloc(utf16_len*4 + 7) : ((void*)0
));
if (str == NULL((void*)0)) {
   free (utf16);
   return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}

strcpy (str, "<FEFF");
for (i = 0; i < utf16_len; i++)
   snprintf (str + 4*i + 5, 5, "%04X", utf16[i]);

strcat (str, ">");
free (utf16);
  }
  *str_out = str;

  return status;
5809}

5811static cairo_int_status_t
5812_cairo_pdf_surface_emit_unicode_for_glyph (cairo_pdf_surface_t	*surface,
			   const char 		*utf8)
5814{
  uint16_t *utf16 = NULL((void*)0);
  int utf16_len = 0;
  cairo_int_status_t status;
  int i;

  if (utf8 && *utf8) {
status = _cairo_utf8_to_utf16 (utf8, -1, &utf16, &utf16_len);
if (unlikely (status == CAIRO_INT_STATUS_INVALID_STRING)(__builtin_expect (!!(status == CAIRO_INT_STATUS_INVALID_STRING
), 0))) {
   utf16 = NULL((void*)0);
   utf16_len = 0;
} else if (unlikely (status)(__builtin_expect (!!(status), 0))) {
   return status;
}
  }

  _cairo_output_stream_printf (surface->output, "<");
  if (utf16 == NULL((void*)0) || utf16_len == 0) {
/* According to the "ToUnicode Mapping File Tutorial"
* http://www.adobe.com/devnet/acrobat/pdfs/5411.ToUnicode.pdf
*
* Glyphs that do not map to a Unicode code point must be
* mapped to 0xfffd "REPLACEMENT CHARACTER".
*/
_cairo_output_stream_printf (surface->output,
		     "fffd");
  } else {
for (i = 0; i < utf16_len; i++)
   _cairo_output_stream_printf (surface->output,
			 "%04x", (int) (utf16[i]));
  }
  _cairo_output_stream_printf (surface->output, ">");

  free (utf16);

  return CAIRO_STATUS_SUCCESS;
5850}

5852/* Bob Jenkins hash
*
* Public domain code from:
*   http://burtleburtle.net/bob/hash/doobs.html
*/

5858#define HASH_MIX(a,b,c){ a -= b; a -= c; a ^= (c>>13); b -= c; b -= a; b ^= (a
<<8); c -= a; c -= b; c ^= (b>>13); a -= b; a -= c
; a ^= (c>>12); b -= c; b -= a; b ^= (a<<16); c -=
 a; c -= b; c ^= (b>>5); a -= b; a -= c; a ^= (c>>
3); b -= c; b -= a; b ^= (a<<10); c -= a; c -= b; c ^= (
b>>15); } 		\
5859{ 					\
  a -= b; a -= c; a ^= (c>>13);	\
  b -= c; b -= a; b ^= (a<<8);	\
  c -= a; c -= b; c ^= (b>>13);	\
  a -= b; a -= c; a ^= (c>>12);	\
  b -= c; b -= a; b ^= (a<<16);	\
  c -= a; c -= b; c ^= (b>>5);	\
  a -= b; a -= c; a ^= (c>>3);	\
  b -= c; b -= a; b ^= (a<<10);	\
  c -= a; c -= b; c ^= (b>>15);	\
5869}

5871static uint32_t
5872_hash_data (const unsigned char *data, int length, uint32_t initval)
5873{
  uint32_t a, b, c, len;

  len = length;
  a = b = 0x9e3779b9;  /* the golden ratio; an arbitrary value */
  c = initval;         /* the previous hash value */

  while (len >= 12) {
a += (data[0] + ((uint32_t)data[1]<<8) + ((uint32_t)data[2]<<16) + ((uint32_t)data[3]<<24));
b += (data[4] + ((uint32_t)data[5]<<8) + ((uint32_t)data[6]<<16) + ((uint32_t)data[7]<<24));
c += (data[8] + ((uint32_t)data[9]<<8) + ((uint32_t)data[10]<<16)+ ((uint32_t)data[11]<<24));
HASH_MIX (a,b,c){ a -= b; a -= c; a ^= (c>>13); b -= c; b -= a; b ^= (a
<<8); c -= a; c -= b; c ^= (b>>13); a -= b; a -= c
; a ^= (c>>12); b -= c; b -= a; b ^= (a<<16); c -=
 a; c -= b; c ^= (b>>5); a -= b; a -= c; a ^= (c>>
3); b -= c; b -= a; b ^= (a<<10); c -= a; c -= b; c ^= (
b>>15); };
data += 12;
len -= 12;
  }

  c += length;
  switch(len) {
  case 11: c+= ((uint32_t) data[10] << 24); /* fall through */
  case 10: c+= ((uint32_t) data[9] << 16);  /* fall through */
  case 9 : c+= ((uint32_t) data[8] << 8);   /* fall through */
  case 8 : b+= ((uint32_t) data[7] << 24);  /* fall through */
  case 7 : b+= ((uint32_t) data[6] << 16);  /* fall through */
  case 6 : b+= ((uint32_t) data[5] << 8);   /* fall through */
  case 5 : b+= data[4];		      /* fall through */
  case 4 : a+= ((uint32_t) data[3] << 24);  /* fall through */
  case 3 : a+= ((uint32_t) data[2] << 16);  /* fall through */
  case 2 : a+= ((uint32_t) data[1] << 8);   /* fall through */
  case 1 : a+= data[0];
  }
  HASH_MIX (a,b,c){ a -= b; a -= c; a ^= (c>>13); b -= c; b -= a; b ^= (a
<<8); c -= a; c -= b; c ^= (b>>13); a -= b; a -= c
; a ^= (c>>12); b -= c; b -= a; b ^= (a<<16); c -=
 a; c -= b; c ^= (b>>5); a -= b; a -= c; a ^= (c>>
3); b -= c; b -= a; b ^= (a<<10); c -= a; c -= b; c ^= (
b>>15); };

  return c;
5906}

5908static void
5909_create_font_subset_tag (cairo_scaled_font_subset_t	*font_subset,
	 const char 			*font_name,
	 char				*tag)
5912{
  uint32_t hash;
  int i;

  hash = _hash_data ((unsigned char *) font_name, strlen(font_name), 0);
  hash = _hash_data ((unsigned char *) (font_subset->glyphs),
       font_subset->num_glyphs * sizeof(unsigned long), hash);

  for (i = 0; i < 6; i++) {
tag[i] = 'A' + (hash % 26);
hash /= 26;
  }
  tag[i] = 0;
5925}

5927static cairo_int_status_t
5928_cairo_pdf_surface_emit_to_unicode_stream (cairo_pdf_surface_t		*surface,
			   cairo_scaled_font_subset_t	*font_subset,
			   cairo_pdf_resource_t         *stream)
5931{
  unsigned int i, num_bfchar;
  cairo_int_status_t status;

  stream->id = 0;

  status = _cairo_pdf_surface_open_stream (surface,
			      NULL((void*)0),
			      surface->compress_streams,
			      NULL((void*)0));
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_output_stream_printf (surface->output,
                               "/CIDInit /ProcSet findresource begin\n"
                               "12 dict begin\n"
                               "begincmap\n"
                               "/CIDSystemInfo\n"
                               "<< /Registry (Adobe)\n"
                               "   /Ordering (UCS)\n"
                               "   /Supplement 0\n"
                               ">> def\n"
                               "/CMapName /Adobe-Identity-UCS def\n"
                               "/CMapType 2 def\n"
                               "1 begincodespacerange\n");

  if (font_subset->is_composite && !font_subset->is_latin) {
      _cairo_output_stream_printf (surface->output,
                                   "<0000> <ffff>\n");
  } else {
      _cairo_output_stream_printf (surface->output,
                                   "<00> <ff>\n");
  }

  _cairo_output_stream_printf (surface->output,
                                "endcodespacerange\n");

  if (font_subset->is_scaled) {
/* Type 3 fonts include glyph 0 in the subset */
num_bfchar = font_subset->num_glyphs;

/* The CMap specification has a limit of 100 characters per beginbfchar operator */
_cairo_output_stream_printf (surface->output,
		     "%d beginbfchar\n",
		     num_bfchar > 100 ? 100 : num_bfchar);

for (i = 0; i < num_bfchar; i++) {
   if (i != 0 && i % 100 == 0) {
_cairo_output_stream_printf (surface->output,
			     "endbfchar\n"
			     "%d beginbfchar\n",
			     num_bfchar - i > 100 ? 100 : num_bfchar - i);
   }
   _cairo_output_stream_printf (surface->output, "<%02x> ", i);
   status = _cairo_pdf_surface_emit_unicode_for_glyph (surface,
						font_subset->utf8[i]);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

   _cairo_output_stream_printf (surface->output,
			 "\n");
}
  } else {
/* Other fonts reserve glyph 0 for .notdef. Omit glyph 0 from the /ToUnicode map */
num_bfchar = font_subset->num_glyphs - 1;

/* The CMap specification has a limit of 100 characters per beginbfchar operator */
_cairo_output_stream_printf (surface->output,
		     "%d beginbfchar\n",
		     num_bfchar > 100 ? 100 : num_bfchar);

for (i = 0; i < num_bfchar; i++) {
   if (i != 0 && i % 100 == 0) {
_cairo_output_stream_printf (surface->output,
			     "endbfchar\n"
			     "%d beginbfchar\n",
			     num_bfchar - i > 100 ? 100 : num_bfchar - i);
   }
   if (font_subset->is_latin)
_cairo_output_stream_printf (surface->output, "<%02x> ", font_subset->to_latin_char[i + 1]);
   else if (font_subset->is_composite)
_cairo_output_stream_printf (surface->output, "<%04x> ", i + 1);
   else
_cairo_output_stream_printf (surface->output, "<%02x> ", i + 1);

   status = _cairo_pdf_surface_emit_unicode_for_glyph (surface,
						font_subset->utf8[i + 1]);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

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

  _cairo_output_stream_printf (surface->output,
                               "endbfchar\n");

  _cairo_output_stream_printf (surface->output,
                               "endcmap\n"
                               "CMapName currentdict /CMap defineresource pop\n"
                               "end\n"
                               "end\n");

  *stream = surface->pdf_stream.self;
  return _cairo_pdf_surface_close_stream (surface);
6037}

6039#define PDF_UNITS_PER_EM1000 1000

6041static cairo_int_status_t
6042_cairo_pdf_surface_emit_cff_font (cairo_pdf_surface_t		*surface,
                                cairo_scaled_font_subset_t	*font_subset,
                                cairo_cff_subset_t            *subset)
6045{
  cairo_pdf_resource_t stream, descriptor, cidfont_dict;
  cairo_pdf_resource_t subset_resource, to_unicode_stream;
  cairo_pdf_font_t font;
  unsigned int i, last_glyph;
  cairo_int_status_t status;
  char tag[10];

  _create_font_subset_tag (font_subset, subset->ps_name, tag);

  subset_resource = _cairo_pdf_surface_get_font_resource (surface,
					    font_subset->font_id,
					    font_subset->subset_id);
  if (subset_resource.id == 0)
return CAIRO_STATUS_SUCCESS;

  status = _cairo_pdf_surface_open_stream (surface,
			     NULL((void*)0),
			     TRUE1,
			     font_subset->is_latin ?
			     "   /Subtype /Type1C\n" :
			     "   /Subtype /CIDFontType0C\n");
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  stream = surface->pdf_stream.self;
  _cairo_output_stream_write (surface->output,
		subset->data, subset->data_length);
  status = _cairo_pdf_surface_close_stream (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  status = _cairo_pdf_surface_emit_to_unicode_stream (surface,
                                               font_subset,
					&to_unicode_stream);
  if (_cairo_int_status_is_error (status)((status) != CAIRO_INT_STATUS_SUCCESS && (status) <
 CAIRO_INT_STATUS_LAST_STATUS))
return status;

  descriptor = _cairo_pdf_surface_new_object (surface);
  if (descriptor.id == 0)
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /Type /FontDescriptor\n"
		 "   /FontName /%s+%s\n",
		 descriptor.id,
		 tag,
		 subset->ps_name);

  if (subset->family_name_utf8) {
char *pdf_str;

status = _cairo_utf8_to_pdf_string (subset->family_name_utf8, &pdf_str);
if (likely (status == CAIRO_INT_STATUS_SUCCESS)(__builtin_expect (!!(status == CAIRO_INT_STATUS_SUCCESS), 1)
)) {
   _cairo_output_stream_printf (surface->output,
			 "   /FontFamily %s\n",
			 pdf_str);
   free (pdf_str);
} else if (status != CAIRO_INT_STATUS_INVALID_STRING) {
   return status;
}
  }

  _cairo_output_stream_printf (surface->output,
		 "   /Flags 4\n"
		 "   /FontBBox [ %ld %ld %ld %ld ]\n"
		 "   /ItalicAngle 0\n"
		 "   /Ascent %ld\n"
		 "   /Descent %ld\n"
		 "   /CapHeight %ld\n"
		 "   /StemV 80\n"
		 "   /StemH 80\n"
		 "   /FontFile3 %u 0 R\n"
		 ">>\n"
		 "endobj\n",
		 (long)(subset->x_min*PDF_UNITS_PER_EM1000),
		 (long)(subset->y_min*PDF_UNITS_PER_EM1000),
		 (long)(subset->x_max*PDF_UNITS_PER_EM1000),
		 (long)(subset->y_max*PDF_UNITS_PER_EM1000),
		 (long)(subset->ascent*PDF_UNITS_PER_EM1000),
		 (long)(subset->descent*PDF_UNITS_PER_EM1000),
		 (long)(subset->y_max*PDF_UNITS_PER_EM1000),
		 stream.id);

  if (font_subset->is_latin) {
/* find last glyph used */
for (i = 255; i >= 32; i--)
   if (font_subset->latin_to_subset_glyph_index[i] > 0)
break;

last_glyph = i;
_cairo_pdf_surface_update_object (surface, subset_resource);
_cairo_output_stream_printf (surface->output,
		     "%d 0 obj\n"
		     "<< /Type /Font\n"
		     "   /Subtype /Type1\n"
		     "   /BaseFont /%s+%s\n"
		     "   /FirstChar 32\n"
		     "   /LastChar %d\n"
		     "   /FontDescriptor %d 0 R\n"
		     "   /Encoding /WinAnsiEncoding\n"
		     "   /Widths [",
		     subset_resource.id,
		     tag,
		     subset->ps_name,
		     last_glyph,
		     descriptor.id);

for (i = 32; i < last_glyph + 1; i++) {
   int glyph = font_subset->latin_to_subset_glyph_index[i];
   if (glyph > 0) {
_cairo_output_stream_printf (surface->output,
			     " %f",
			     (subset->widths[glyph]*PDF_UNITS_PER_EM1000));
   } else {
_cairo_output_stream_printf (surface->output, " 0");
   }
}

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

if (to_unicode_stream.id != 0)
   _cairo_output_stream_printf (surface->output,
			 "    /ToUnicode %d 0 R\n",
			 to_unicode_stream.id);

_cairo_output_stream_printf (surface->output,
		     ">>\n"
		     "endobj\n");
  } else {
cidfont_dict = _cairo_pdf_surface_new_object (surface);
if (cidfont_dict.id == 0)
   return _cairo_error (CAIRO_STATUS_NO_MEMORY);

_cairo_output_stream_printf (surface->output,
		     "%d 0 obj\n"
		     "<< /Type /Font\n"
		     "   /Subtype /CIDFontType0\n"
		     "   /BaseFont /%s+%s\n"
		     "   /CIDSystemInfo\n"
		     "   << /Registry (Adobe)\n"
		     "      /Ordering (Identity)\n"
		     "      /Supplement 0\n"
		     "   >>\n"
		     "   /FontDescriptor %d 0 R\n"
		     "   /W [0 [",
		     cidfont_dict.id,
		     tag,
		     subset->ps_name,
		     descriptor.id);

for (i = 0; i < font_subset->num_glyphs; i++)
   _cairo_output_stream_printf (surface->output,
			 " %f",
			 (subset->widths[i]*PDF_UNITS_PER_EM1000));

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

_cairo_pdf_surface_update_object (surface, subset_resource);
_cairo_output_stream_printf (surface->output,
		     "%d 0 obj\n"
		     "<< /Type /Font\n"
		     "   /Subtype /Type0\n"
		     "   /BaseFont /%s+%s\n"
		     "   /Encoding /Identity-H\n"
		     "   /DescendantFonts [ %d 0 R]\n",
		     subset_resource.id,
		     tag,
		     subset->ps_name,
		     cidfont_dict.id);

if (to_unicode_stream.id != 0)
   _cairo_output_stream_printf (surface->output,
			 "   /ToUnicode %d 0 R\n",
			 to_unicode_stream.id);

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

  font.font_id = font_subset->font_id;
  font.subset_id = font_subset->subset_id;
  font.subset_resource = subset_resource;
  status = _cairo_array_append (&surface->fonts, &font);

  return status;
6237}

6239static cairo_int_status_t
6240_cairo_pdf_surface_emit_cff_font_subset (cairo_pdf_surface_t	     *surface,
                                       cairo_scaled_font_subset_t  *font_subset)
6242{
  cairo_int_status_t status;
  cairo_cff_subset_t subset;
  char name[64];

  snprintf (name, sizeof name, "CairoFont-%d-%d",
            font_subset->font_id, font_subset->subset_id);
  status = _cairo_cff_subset_init (&subset, name, font_subset);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
      return status;

  status = _cairo_pdf_surface_emit_cff_font (surface, font_subset, &subset);

  _cairo_cff_subset_fini (&subset);

  return status;
6258}

6260static cairo_int_status_t
6261_cairo_pdf_surface_emit_cff_fallback_font (cairo_pdf_surface_t	       *surface,
                                         cairo_scaled_font_subset_t  *font_subset)
6263{
  cairo_int_status_t status;
  cairo_cff_subset_t subset;
  char name[64];

  /* CFF fallback subsetting does not work with 8-bit glyphs unless
   * they are a latin subset */
  if (!font_subset->is_composite && !font_subset->is_latin)
return CAIRO_INT_STATUS_UNSUPPORTED;

  snprintf (name, sizeof name, "CairoFont-%d-%d",
            font_subset->font_id, font_subset->subset_id);
  status = _cairo_cff_fallback_init (&subset, name, font_subset);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
      return status;

  status = _cairo_pdf_surface_emit_cff_font (surface, font_subset, &subset);

  _cairo_cff_fallback_fini (&subset);

  return status;
6284}

6286static cairo_int_status_t
6287_cairo_pdf_surface_emit_type1_font (cairo_pdf_surface_t		*surface,
                                  cairo_scaled_font_subset_t	*font_subset,
                                  cairo_type1_subset_t        *subset)
6290{
  cairo_pdf_resource_t stream, descriptor, subset_resource, to_unicode_stream;
  cairo_pdf_font_t font;
  cairo_int_status_t status;
  unsigned long length;
  unsigned int i, last_glyph;
  char tag[10];

  _create_font_subset_tag (font_subset, subset->base_font, tag);

  subset_resource = _cairo_pdf_surface_get_font_resource (surface,
					    font_subset->font_id,
					    font_subset->subset_id);
  if (subset_resource.id == 0)
return CAIRO_STATUS_SUCCESS;

  length = subset->header_length + subset->data_length + subset->trailer_length;
  status = _cairo_pdf_surface_open_stream (surface,
			     NULL((void*)0),
			     TRUE1,
			     "   /Length1 %lu\n"
			     "   /Length2 %lu\n"
			     "   /Length3 %lu\n",
			     subset->header_length,
			     subset->data_length,
			     subset->trailer_length);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  stream = surface->pdf_stream.self;
  _cairo_output_stream_write (surface->output, subset->data, length);
  status = _cairo_pdf_surface_close_stream (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  status = _cairo_pdf_surface_emit_to_unicode_stream (surface,
                                               font_subset,
					&to_unicode_stream);
  if (_cairo_int_status_is_error (status)((status) != CAIRO_INT_STATUS_SUCCESS && (status) <
 CAIRO_INT_STATUS_LAST_STATUS))
return status;

  last_glyph = font_subset->num_glyphs - 1;
  if (font_subset->is_latin) {
/* find last glyph used */
for (i = 255; i >= 32; i--)
   if (font_subset->latin_to_subset_glyph_index[i] > 0)
break;

last_glyph = i;
  }

  descriptor = _cairo_pdf_surface_new_object (surface);
  if (descriptor.id == 0)
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /Type /FontDescriptor\n"
		 "   /FontName /%s+%s\n"
		 "   /Flags 4\n"
		 "   /FontBBox [ %ld %ld %ld %ld ]\n"
		 "   /ItalicAngle 0\n"
		 "   /Ascent %ld\n"
		 "   /Descent %ld\n"
		 "   /CapHeight %ld\n"
		 "   /StemV 80\n"
		 "   /StemH 80\n"
		 "   /FontFile %u 0 R\n"
		 ">>\n"
		 "endobj\n",
		 descriptor.id,
		 tag,
		 subset->base_font,
		 (long)(subset->x_min*PDF_UNITS_PER_EM1000),
		 (long)(subset->y_min*PDF_UNITS_PER_EM1000),
		 (long)(subset->x_max*PDF_UNITS_PER_EM1000),
		 (long)(subset->y_max*PDF_UNITS_PER_EM1000),
		 (long)(subset->ascent*PDF_UNITS_PER_EM1000),
		 (long)(subset->descent*PDF_UNITS_PER_EM1000),
		 (long)(subset->y_max*PDF_UNITS_PER_EM1000),
		 stream.id);

  _cairo_pdf_surface_update_object (surface, subset_resource);
  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /Type /Font\n"
		 "   /Subtype /Type1\n"
		 "   /BaseFont /%s+%s\n"
		 "   /FirstChar %d\n"
		 "   /LastChar %d\n"
		 "   /FontDescriptor %d 0 R\n",
		 subset_resource.id,
		 tag,
		 subset->base_font,
		 font_subset->is_latin ? 32 : 0,
		 last_glyph,
		 descriptor.id);

  if (font_subset->is_latin)
_cairo_output_stream_printf (surface->output, "   /Encoding /WinAnsiEncoding\n");

  _cairo_output_stream_printf (surface->output, "   /Widths [");
  if (font_subset->is_latin) {
for (i = 32; i < last_glyph + 1; i++) {
   int glyph = font_subset->latin_to_subset_glyph_index[i];
   if (glyph > 0) {
_cairo_output_stream_printf (surface->output,
			     " %f",
			     (subset->widths[glyph]*PDF_UNITS_PER_EM1000));
   } else {
_cairo_output_stream_printf (surface->output, " 0");
   }
}
  } else {
for (i = 0; i < font_subset->num_glyphs; i++)
   _cairo_output_stream_printf (surface->output,
			 " %f",
			 (subset->widths[i]*PDF_UNITS_PER_EM1000));
  }

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

  if (to_unicode_stream.id != 0)
      _cairo_output_stream_printf (surface->output,
                                   "    /ToUnicode %d 0 R\n",
                                   to_unicode_stream.id);

  _cairo_output_stream_printf (surface->output,
		 ">>\n"
		 "endobj\n");

  font.font_id = font_subset->font_id;
  font.subset_id = font_subset->subset_id;
  font.subset_resource = subset_resource;
  return _cairo_array_append (&surface->fonts, &font);
6426}

6428static cairo_int_status_t
6429_cairo_pdf_surface_emit_type1_font_subset (cairo_pdf_surface_t		*surface,
			   cairo_scaled_font_subset_t	*font_subset)
6431{
  cairo_int_status_t status;
  cairo_type1_subset_t subset;
  char name[64];

  /* 16-bit glyphs not compatible with Type 1 fonts */
  if (font_subset->is_composite && !font_subset->is_latin)
return CAIRO_INT_STATUS_UNSUPPORTED;

  snprintf (name, sizeof name, "CairoFont-%d-%d",
     font_subset->font_id, font_subset->subset_id);
  status = _cairo_type1_subset_init (&subset, name, font_subset, FALSE0);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  status = _cairo_pdf_surface_emit_type1_font (surface, font_subset, &subset);

  _cairo_type1_subset_fini (&subset);
  return status;
6450}

6452static cairo_int_status_t
6453_cairo_pdf_surface_emit_type1_fallback_font (cairo_pdf_surface_t	*surface,
                                           cairo_scaled_font_subset_t	*font_subset)
6455{
  cairo_int_status_t status;
  cairo_type1_subset_t subset;
  char name[64];

  /* 16-bit glyphs not compatible with Type 1 fonts */
  if (font_subset->is_composite && !font_subset->is_latin)
return CAIRO_INT_STATUS_UNSUPPORTED;

  snprintf (name, sizeof name, "CairoFont-%d-%d",
     font_subset->font_id, font_subset->subset_id);
  status = _cairo_type1_fallback_init_binary (&subset, name, font_subset);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  status = _cairo_pdf_surface_emit_type1_font (surface, font_subset, &subset);

  _cairo_type1_fallback_fini (&subset);
  return status;
6474}

6476static cairo_int_status_t
6477_cairo_pdf_surface_emit_truetype_font_subset (cairo_pdf_surface_t		*surface,
			      cairo_scaled_font_subset_t	*font_subset)
6479{
  cairo_pdf_resource_t stream, descriptor, cidfont_dict;
  cairo_pdf_resource_t subset_resource, to_unicode_stream;
  cairo_int_status_t status;
  cairo_pdf_font_t font;
  cairo_truetype_subset_t subset;
  unsigned int i, last_glyph;
  char tag[10];

  subset_resource = _cairo_pdf_surface_get_font_resource (surface,
					    font_subset->font_id,
					    font_subset->subset_id);
  if (subset_resource.id == 0)
return CAIRO_STATUS_SUCCESS;

  status = _cairo_truetype_subset_init_pdf (&subset, font_subset);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _create_font_subset_tag (font_subset, subset.ps_name, tag);

  status = _cairo_pdf_surface_open_stream (surface,
			     NULL((void*)0),
			     TRUE1,
			     "   /Length1 %lu\n",
			     subset.data_length);
  if (unlikely (status)(__builtin_expect (!!(status), 0))) {
_cairo_truetype_subset_fini (&subset);
return status;
  }

  stream = surface->pdf_stream.self;
  _cairo_output_stream_write (surface->output,
		subset.data, subset.data_length);
  status = _cairo_pdf_surface_close_stream (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0))) {
_cairo_truetype_subset_fini (&subset);
return status;
  }

  status = _cairo_pdf_surface_emit_to_unicode_stream (surface,
                                               font_subset,
					&to_unicode_stream);
  if (_cairo_int_status_is_error (status)((status) != CAIRO_INT_STATUS_SUCCESS && (status) <
 CAIRO_INT_STATUS_LAST_STATUS)) {
_cairo_truetype_subset_fini (&subset);
return status;
  }

  descriptor = _cairo_pdf_surface_new_object (surface);
  if (descriptor.id == 0) {
_cairo_truetype_subset_fini (&subset);
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
  }

  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /Type /FontDescriptor\n"
		 "   /FontName /%s+%s\n",
		 descriptor.id,
		 tag,
		 subset.ps_name);

  if (subset.family_name_utf8) {
char *pdf_str;

status = _cairo_utf8_to_pdf_string (subset.family_name_utf8, &pdf_str);
if (likely (status == CAIRO_INT_STATUS_SUCCESS)(__builtin_expect (!!(status == CAIRO_INT_STATUS_SUCCESS), 1)
)) {
   _cairo_output_stream_printf (surface->output,
			 "   /FontFamily %s\n",
			 pdf_str);
   free (pdf_str);
} else if (status != CAIRO_INT_STATUS_INVALID_STRING) {
   return status;
}
  }

  _cairo_output_stream_printf (surface->output,
		 "   /Flags %d\n"
		 "   /FontBBox [ %ld %ld %ld %ld ]\n"
		 "   /ItalicAngle 0\n"
		 "   /Ascent %ld\n"
		 "   /Descent %ld\n"
		 "   /CapHeight %ld\n"
		 "   /StemV 80\n"
		 "   /StemH 80\n"
		 "   /FontFile2 %u 0 R\n"
		 ">>\n"
		 "endobj\n",
		 font_subset->is_latin ? 32 : 4,
		 (long)(subset.x_min*PDF_UNITS_PER_EM1000),
		 (long)(subset.y_min*PDF_UNITS_PER_EM1000),
                               (long)(subset.x_max*PDF_UNITS_PER_EM1000),
		 (long)(subset.y_max*PDF_UNITS_PER_EM1000),
		 (long)(subset.ascent*PDF_UNITS_PER_EM1000),
		 (long)(subset.descent*PDF_UNITS_PER_EM1000),
		 (long)(subset.y_max*PDF_UNITS_PER_EM1000),
		 stream.id);

  if (font_subset->is_latin) {
/* find last glyph used */
for (i = 255; i >= 32; i--)
   if (font_subset->latin_to_subset_glyph_index[i] > 0)
break;

last_glyph = i;
_cairo_pdf_surface_update_object (surface, subset_resource);
_cairo_output_stream_printf (surface->output,
		     "%d 0 obj\n"
		     "<< /Type /Font\n"
		     "   /Subtype /TrueType\n"
		     "   /BaseFont /%s+%s\n"
		     "   /FirstChar 32\n"
		     "   /LastChar %d\n"
		     "   /FontDescriptor %d 0 R\n"
		     "   /Encoding /WinAnsiEncoding\n"
		     "   /Widths [",
		     subset_resource.id,
		     tag,
		     subset.ps_name,
		     last_glyph,
		     descriptor.id);

for (i = 32; i < last_glyph + 1; i++) {
   int glyph = font_subset->latin_to_subset_glyph_index[i];
   if (glyph > 0) {
_cairo_output_stream_printf (surface->output,
			     " %f",
			     (subset.widths[glyph]*PDF_UNITS_PER_EM1000));
   } else {
_cairo_output_stream_printf (surface->output, " 0");
   }
}

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

if (to_unicode_stream.id != 0)
   _cairo_output_stream_printf (surface->output,
			 "    /ToUnicode %d 0 R\n",
			 to_unicode_stream.id);

_cairo_output_stream_printf (surface->output,
		     ">>\n"
		     "endobj\n");
  } else {
cidfont_dict = _cairo_pdf_surface_new_object (surface);
if (cidfont_dict.id == 0) {
   _cairo_truetype_subset_fini (&subset);
   return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}

_cairo_output_stream_printf (surface->output,
		     "%d 0 obj\n"
		     "<< /Type /Font\n"
		     "   /Subtype /CIDFontType2\n"
		     "   /BaseFont /%s+%s\n"
		     "   /CIDSystemInfo\n"
		     "   << /Registry (Adobe)\n"
		     "      /Ordering (Identity)\n"
		     "      /Supplement 0\n"
		     "   >>\n"
		     "   /FontDescriptor %d 0 R\n"
		     "   /W [0 [",
		     cidfont_dict.id,
		     tag,
		     subset.ps_name,
		     descriptor.id);

for (i = 0; i < font_subset->num_glyphs; i++)
   _cairo_output_stream_printf (surface->output,
			 " %f",
			 (subset.widths[i]*PDF_UNITS_PER_EM1000));

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

_cairo_pdf_surface_update_object (surface, subset_resource);
_cairo_output_stream_printf (surface->output,
		     "%d 0 obj\n"
		     "<< /Type /Font\n"
		     "   /Subtype /Type0\n"
		     "   /BaseFont /%s+%s\n"
		     "   /Encoding /Identity-H\n"
		     "   /DescendantFonts [ %d 0 R]\n",
		     subset_resource.id,
		     tag,
		     subset.ps_name,
		     cidfont_dict.id);

if (to_unicode_stream.id != 0)
   _cairo_output_stream_printf (surface->output,
			 "   /ToUnicode %d 0 R\n",
			 to_unicode_stream.id);

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

  font.font_id = font_subset->font_id;
  font.subset_id = font_subset->subset_id;
  font.subset_resource = subset_resource;
  status = _cairo_array_append (&surface->fonts, &font);

  _cairo_truetype_subset_fini (&subset);

  return status;
6688}

6690static cairo_int_status_t
6691_cairo_pdf_emit_imagemask (cairo_image_surface_t *image,
	     cairo_output_stream_t *stream)
6693{
  uint8_t *byte, output_byte;
  int row, col, num_cols;

  /* The only image type supported by Type 3 fonts are 1-bit image
   * masks */
  assert (image->format == CAIRO_FORMAT_A1)((void) sizeof (__assert_single_arg (image->format == CAIRO_FORMAT_A1
)), __extension__ ({ if (image->format == CAIRO_FORMAT_A1)
 ; else __assert_fail ("image->format == CAIRO_FORMAT_A1",
 "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 6699, __extension__ __PRETTY_FUNCTION__); }));

  _cairo_output_stream_printf (stream,
		 "BI\n"
		 "/IM true\n"
		 "/W %d\n"
		 "/H %d\n"
		 "/BPC 1\n"
		 "/D [1 0]\n",
		 image->width,
		 image->height);

  _cairo_output_stream_printf (stream,
		 "ID ");

  num_cols = (image->width + 7) / 8;
  for (row = 0; row < image->height; row++) {
byte = image->data + row * image->stride;
for (col = 0; col < num_cols; col++) {
   output_byte = CAIRO_BITSWAP8_IF_LITTLE_ENDIAN (*byte)((((*byte) * 0x0802LU & 0x22110LU) | ((*byte) * 0x8020LU &
 0x88440LU)) * 0x10101LU >> 16);
   _cairo_output_stream_write (stream, &output_byte, 1);
   byte++;
}
  }

  _cairo_output_stream_printf (stream,
		 "\nEI\n");

  return _cairo_output_stream_get_status (stream);
6728}

6730static cairo_int_status_t
6731cairo_pdf_surface_emit_color_glyph (cairo_pdf_surface_t *surface,
		    cairo_scaled_font_t *scaled_font,
		    unsigned long	 glyph_index,
		    cairo_box_t         *bbox,
		    double              *width)
6736{
  cairo_rectangle_int_t extents;
  cairo_scaled_glyph_t *scaled_glyph;
  cairo_matrix_t mat;
  cairo_int_status_t status;
  double x_advance, y_advance;
  cairo_matrix_t font_matrix_inverse;
  cairo_surface_t *analysis;
  cairo_rectangle_int_t old_surface_extents;
  cairo_bool_t old_surface_bounded;
  cairo_paginated_mode_t old_paginated_mode;
  cairo_surface_t *glyph_surface = NULL((void*)0);
  unsigned int regions_id = 0;
  cairo_surface_pattern_t surface_pattern;

  _cairo_scaled_font_freeze_cache (scaled_font);
  status = _cairo_scaled_glyph_lookup (scaled_font,
			 glyph_index,
			 CAIRO_SCALED_GLYPH_INFO_RECORDING_SURFACE,
			 NULL((void*)0), /* foreground color */
			 &scaled_glyph);
  if (status == CAIRO_INT_STATUS_SUCCESS)
glyph_surface = cairo_surface_reference_moz_cairo_surface_reference (scaled_glyph->recording_surface);

  _cairo_scaled_font_thaw_cache (scaled_font);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  analysis = _cairo_analysis_surface_create (&surface->base, TRUE1);
  if (unlikely (analysis->status)(__builtin_expect (!!(analysis->status), 0))) {
status = _cairo_surface_set_error (&surface->base, analysis->status);
goto cleanup;
  }

  extents.x = _cairo_fixed_to_double (scaled_glyph->bbox.p1.x);
  extents.y = _cairo_fixed_to_double (scaled_glyph->bbox.p1.y);
  extents.width = _cairo_fixed_to_double (scaled_glyph->bbox.p2.x) - extents.x;
  extents.height = _cairo_fixed_to_double (scaled_glyph->bbox.p2.y) - extents.y;

  old_surface_extents = surface->surface_extents;
  old_surface_bounded = surface->surface_bounded;
  old_paginated_mode = surface->paginated_mode;
  surface->paginated_mode = CAIRO_PAGINATED_MODE_ANALYZE;
  surface->type3_replay = TRUE1;
  surface->surface_extents = extents;
  surface->surface_bounded = TRUE1;

  status = _cairo_recording_surface_region_array_attach (glyph_surface, &regions_id);
  if (status)
goto cleanup;

  status = _cairo_recording_surface_replay_and_create_regions (glyph_surface, regions_id,
                                                               NULL((void*)0), analysis, TRUE1, FALSE0);
  if (status)
goto cleanup;

  surface->surface_extents = old_surface_extents;
  surface->surface_bounded = old_surface_bounded;
  surface->paginated_mode = old_paginated_mode;
  surface->type3_replay = FALSE0;

  if (status ==  CAIRO_INT_STATUS_SUCCESS &&
_cairo_analysis_surface_has_unsupported (analysis))
  {
status = CAIRO_INT_STATUS_UNSUPPORTED;
  }

  cairo_surface_destroy_moz_cairo_surface_destroy (analysis);
  if (status)
goto cleanup;

  _cairo_pattern_init_for_surface (&surface_pattern, glyph_surface);
  surface_pattern.region_array_id = regions_id;

  cairo_matrix_init_identity_moz_cairo_matrix_init_identity (&mat);
  cairo_matrix_multiply_moz_cairo_matrix_multiply (&mat, &mat, &scaled_font->scale_inverse);

  /* transform glyph extents to operation space */
  cairo_box_t box;
  _cairo_box_from_rectangle (&box, &extents);
  _cairo_matrix_transform_bounding_box_fixed (&mat, &box, NULL((void*)0));
  _cairo_box_round_to_rectangle (&box, &extents);

  status = cairo_matrix_invert_moz_cairo_matrix_invert (&mat);
  if (status) {
status = CAIRO_INT_STATUS_UNSUPPORTED;
goto cleanup;
  }

  cairo_pattern_set_matrix_moz_cairo_pattern_set_matrix (&surface_pattern.base, &mat);

  x_advance = scaled_glyph->metrics.x_advance;
  y_advance = scaled_glyph->metrics.y_advance;
  font_matrix_inverse = scaled_font->font_matrix;
  status = cairo_matrix_invert_moz_cairo_matrix_invert (&font_matrix_inverse);
  if (status) {
status = CAIRO_INT_STATUS_UNSUPPORTED;
goto cleanup;
  }

  cairo_matrix_transform_distance_moz_cairo_matrix_transform_distance (&font_matrix_inverse, &x_advance, &y_advance);
  *width = x_advance;

  *bbox = scaled_glyph->bbox;
  _cairo_matrix_transform_bounding_box_fixed (&scaled_font->scale_inverse,
				bbox, NULL((void*)0));

  _cairo_output_stream_printf (surface->output,
		 "%f 0 d0\n",
		 x_advance);

  _cairo_pdf_surface_paint_surface_pattern (surface,
			      CAIRO_OPERATOR_OVER,
			      &surface_pattern.base,
			      CAIRO_ANALYSIS_SOURCE_NONE,
			      &extents,
			      1.0, /* alpha */
			      NULL((void*)0), /* smask_res */
			      FALSE0); /* mask */

cleanup:
  cairo_surface_destroy_moz_cairo_surface_destroy (glyph_surface);

  return status;
6860}

6862static cairo_int_status_t
6863cairo_pdf_surface_emit_color_glyph_image (cairo_pdf_surface_t *surface,
			  cairo_scaled_font_t *scaled_font,
			  unsigned long	       glyph_index,
			  cairo_box_t         *bbox,
			  double              *width)
6868{
  cairo_rectangle_int_t extents;
  cairo_pattern_t *image_pattern;
  cairo_scaled_glyph_t *scaled_glyph;
  cairo_matrix_t mat;
  cairo_int_status_t status, status2;
  double x_advance, y_advance;
  cairo_matrix_t font_matrix_inverse;

  _cairo_scaled_font_freeze_cache (scaled_font);
  status = _cairo_scaled_glyph_lookup (scaled_font,
			 glyph_index,
			 CAIRO_SCALED_GLYPH_INFO_COLOR_SURFACE,
			 NULL((void*)0), /* foreground color */
			 &scaled_glyph);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto FAIL;

  extents.x = _cairo_fixed_to_double (scaled_glyph->bbox.p1.x);
  extents.y = _cairo_fixed_to_double (scaled_glyph->bbox.p1.y);
  extents.width = _cairo_fixed_to_double (scaled_glyph->bbox.p2.x) - extents.x;
  extents.height = _cairo_fixed_to_double (scaled_glyph->bbox.p2.y) - extents.y;

  image_pattern = cairo_pattern_create_for_surface_moz_cairo_pattern_create_for_surface (&scaled_glyph->color_surface->base);

  cairo_matrix_init_translate_moz_cairo_matrix_init_translate (&mat, extents.x, extents.y);
  cairo_matrix_multiply_moz_cairo_matrix_multiply (&mat, &mat, &scaled_font->scale_inverse);
  status2 = cairo_matrix_invert_moz_cairo_matrix_invert (&mat);
  cairo_pattern_set_matrix_moz_cairo_pattern_set_matrix (image_pattern, &mat);

  x_advance = scaled_glyph->metrics.x_advance;
  y_advance = scaled_glyph->metrics.y_advance;
  font_matrix_inverse = scaled_font->font_matrix;
  status2 = cairo_matrix_invert_moz_cairo_matrix_invert (&font_matrix_inverse);

  /* The invertability of font_matrix is tested in
   * pdf_operators_show_glyphs before any glyphs are mapped to the
   * subset. */
  assert (status2 == CAIRO_INT_STATUS_SUCCESS)((void) sizeof (__assert_single_arg (status2 == CAIRO_INT_STATUS_SUCCESS
)), __extension__ ({ if (status2 == CAIRO_INT_STATUS_SUCCESS)
 ; else __assert_fail ("status2 == CAIRO_INT_STATUS_SUCCESS",
 "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 6906, __extension__ __PRETTY_FUNCTION__); }));

  cairo_matrix_transform_distance_moz_cairo_matrix_transform_distance (&font_matrix_inverse, &x_advance, &y_advance);
  *width = x_advance;

  *bbox = scaled_glyph->bbox;
  _cairo_matrix_transform_bounding_box_fixed (&scaled_font->scale_inverse,
				bbox, NULL((void*)0));

  _cairo_output_stream_printf (surface->output,
		 "%f 0 d0\n",
		 x_advance);

  _cairo_pdf_surface_paint_surface_pattern (surface,
			      CAIRO_OPERATOR_OVER,
			      image_pattern,
			      CAIRO_ANALYSIS_SOURCE_NONE,
			      &extents,
			      1.0, /* alpha */
			      NULL((void*)0), /* smask_res */
			      FALSE0); /* mask */
  cairo_pattern_destroy_moz_cairo_pattern_destroy (image_pattern);
FAIL:
  _cairo_scaled_font_thaw_cache (scaled_font);

  return status;
6932}

6934static cairo_int_status_t
6935_cairo_pdf_surface_emit_type3_font_subset (cairo_pdf_surface_t		*surface,
			   cairo_scaled_font_subset_t	*font_subset)
6937{
  cairo_int_status_t status = CAIRO_STATUS_SUCCESS;
  cairo_pdf_resource_t *glyphs, encoding, char_procs, subset_resource, to_unicode_stream;
  cairo_pdf_font_t font;
  double *widths;
  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;

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

  subset_resource = _cairo_pdf_surface_get_font_resource (surface,
					    font_subset->font_id,
					    font_subset->subset_id);
  if (subset_resource.id == 0)
return CAIRO_STATUS_SUCCESS;

  glyphs = _cairo_malloc_ab (font_subset->num_glyphs, sizeof (cairo_pdf_resource_t));
  if (unlikely (glyphs == NULL)(__builtin_expect (!!(glyphs == ((void*)0)), 0)))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  widths = _cairo_malloc_ab (font_subset->num_glyphs, sizeof (double));
  if (unlikely (widths == NULL)(__builtin_expect (!!(widths == ((void*)0)), 0))) {
      free (glyphs);
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
  }

  _cairo_pdf_group_resources_clear (&surface->resources);
  type3_surface = _cairo_type3_glyph_surface_create (font_subset->scaled_font,
				       NULL((void*)0),
				       _cairo_pdf_emit_imagemask,
				       surface->font_subsets,
				       FALSE0);
  if (unlikely (type3_surface->status)(__builtin_expect (!!(type3_surface->status), 0))) {
      free (glyphs);
      free (widths);
return type3_surface->status;
  }

  _cairo_type3_glyph_surface_set_font_subsets_callback (type3_surface,
					  _cairo_pdf_surface_add_font,
					  surface);

  for (i = 0; i < font_subset->num_glyphs; i++) {
status = _cairo_pdf_surface_open_stream (surface,
				 NULL((void*)0),
				 surface->compress_streams,
				 NULL((void*)0));
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   break;

glyphs[i] = surface->pdf_stream.self;
status = _cairo_type3_glyph_surface_emit_glyph (type3_surface,
					surface->output,
					font_subset->glyphs[i],
					&bbox,
					&widths[i]);
if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
   status = cairo_pdf_surface_emit_color_glyph (surface,
					 font_subset->scaled_font,
					 font_subset->glyphs[i],
					 &bbox,
					 &widths[i]);
   if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
status = cairo_pdf_surface_emit_color_glyph_image (surface,
						   font_subset->scaled_font,
						   font_subset->glyphs[i],
						   &bbox,
						   &widths[i]);
   }
}
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   break;

status = _cairo_pdf_surface_close_stream (surface);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   break;

      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_destroy_moz_cairo_surface_destroy (type3_surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0))) {
free (glyphs);
free (widths);
return status;
  }

  encoding = _cairo_pdf_surface_new_object (surface);
  if (encoding.id == 0) {
free (glyphs);
free (widths);
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
  }

  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /Type /Encoding\n"
		 "   /Differences [0", encoding.id);
  for (i = 0; i < font_subset->num_glyphs; i++)
_cairo_output_stream_printf (surface->output,
		     " /%d", i);
  _cairo_output_stream_printf (surface->output,
		 "]\n"
		 ">>\n"
		 "endobj\n");

  char_procs = _cairo_pdf_surface_new_object (surface);
  if (char_procs.id == 0) {
free (glyphs);
free (widths);
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
  }

  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<<\n", char_procs.id);
  for (i = 0; i < font_subset->num_glyphs; i++)
_cairo_output_stream_printf (surface->output,
		     " /%d %d 0 R\n",
		     i, glyphs[i].id);
  _cairo_output_stream_printf (surface->output,
		 ">>\n"
		 "endobj\n");

  free (glyphs);

  status = _cairo_pdf_surface_emit_to_unicode_stream (surface,
                                               font_subset,
					&to_unicode_stream);
  if (_cairo_int_status_is_error (status)((status) != CAIRO_INT_STATUS_SUCCESS && (status) <
 CAIRO_INT_STATUS_LAST_STATUS)) {
free (widths);
return status;
  }

  _cairo_pdf_surface_update_object (surface, subset_resource);
  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /Type /Font\n"
		 "   /Subtype /Type3\n"
		 "   /FontBBox [%f %f %f %f]\n"
		 "   /FontMatrix [ 1 0 0 -1 0 0 ]\n"
		 "   /Encoding %d 0 R\n"
		 "   /CharProcs %d 0 R\n"
		 "   /FirstChar 0\n"
		 "   /LastChar %d\n",
		 subset_resource.id,
		 _cairo_fixed_to_double (font_bbox.p1.x),
		 _cairo_fixed_to_double (font_bbox.p1.y),
		 _cairo_fixed_to_double (font_bbox.p2.x),
		 _cairo_fixed_to_double (font_bbox.p2.y),
		 encoding.id,
		 char_procs.id,
		 font_subset->num_glyphs - 1);

  _cairo_output_stream_printf (surface->output,
		 "   /Widths [");
  for (i = 0; i < font_subset->num_glyphs; i++)
_cairo_output_stream_printf (surface->output, " %f", widths[i]);
  _cairo_output_stream_printf (surface->output,
		 "]\n");
  free (widths);

  _cairo_output_stream_printf (surface->output,
		 "   /Resources\n");
  _cairo_pdf_surface_emit_group_resources (surface, &surface->resources, FALSE0);

  if (to_unicode_stream.id != 0)
      _cairo_output_stream_printf (surface->output,
                                   "    /ToUnicode %d 0 R\n",
                                   to_unicode_stream.id);

  _cairo_output_stream_printf (surface->output,
		 ">>\n"
		 "endobj\n");

  font.font_id = font_subset->font_id;
  font.subset_id = font_subset->subset_id;
  font.subset_resource = subset_resource;
  return _cairo_array_append (&surface->fonts, &font);
7132}

7134static cairo_int_status_t
7135_cairo_pdf_surface_emit_unscaled_font_subset (cairo_scaled_font_subset_t *font_subset,
                                            void			 *closure)
7137{
  cairo_pdf_surface_t *surface = closure;
  cairo_int_status_t status;

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

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

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

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

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

  ASSERT_NOT_REACHEDdo { ((void) sizeof (__assert_single_arg (!"reached")), __extension__
 ({ if (!"reached") ; else __assert_fail ("!\"reached\"", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 7161, __extension__ __PRETTY_FUNCTION__); })); } while (0);
  return CAIRO_INT_STATUS_SUCCESS;
7163}

7165static cairo_int_status_t
7166_cairo_pdf_surface_emit_scaled_font_subset (cairo_scaled_font_subset_t *font_subset,
                                          void		       *closure)
7168{
  cairo_pdf_surface_t *surface = closure;
  cairo_int_status_t status;

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

  ASSERT_NOT_REACHEDdo { ((void) sizeof (__assert_single_arg (!"reached")), __extension__
 ({ if (!"reached") ; else __assert_fail ("!\"reached\"", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 7176, __extension__ __PRETTY_FUNCTION__); })); } while (0);
  return CAIRO_INT_STATUS_SUCCESS;
7178}

7180static cairo_int_status_t
7181_cairo_pdf_surface_emit_font_subsets (cairo_pdf_surface_t *surface)
7182{
  cairo_int_status_t status;

  status = _cairo_scaled_font_subsets_foreach_unscaled (surface->font_subsets,
                                                        _cairo_pdf_surface_emit_unscaled_font_subset,
                                                        surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto BAIL;

  status = _cairo_scaled_font_subsets_foreach_scaled (surface->font_subsets,
                                                      _cairo_pdf_surface_emit_scaled_font_subset,
                                                      surface);

7195BAIL:
  _cairo_scaled_font_subsets_destroy (surface->font_subsets);
  surface->font_subsets = NULL((void*)0);

  return status;
7200}

7202static cairo_int_status_t
7203_cairo_pdf_surface_write_catalog (cairo_pdf_surface_t *surface,
		  cairo_pdf_resource_t catalog)
7205{
  cairo_status_t status;

  status = _cairo_pdf_surface_object_begin (surface, catalog);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_output_stream_printf (surface->object_stream.stream,
		 "<< /Type /Catalog\n"
		 "   /Pages %d 0 R\n",
		 surface->pages_resource.id);

  if (surface->struct_tree_root.id != 0) {
_cairo_output_stream_printf (surface->object_stream.stream,
		     "   /StructTreeRoot %d 0 R\n",
		     surface->struct_tree_root.id);
if (surface->tagged) {
   _cairo_output_stream_printf (surface->object_stream.stream,
			 "   /MarkInfo << /Marked true >>\n");
}
  }

  if (surface->outlines_dict_res.id != 0) {
_cairo_output_stream_printf (surface->object_stream.stream,
		     "   /Outlines %d 0 R\n",
		     surface->outlines_dict_res.id);
  }

  if (surface->page_labels_res.id != 0) {
_cairo_output_stream_printf (surface->object_stream.stream,
		     "   /PageLabels %d 0 R\n",
		     surface->page_labels_res.id);
  }

  if (surface->names_dict_res.id != 0) {
_cairo_output_stream_printf (surface->object_stream.stream,
		     "   /Names %d 0 R\n",
		     surface->names_dict_res.id);
  }

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

  return status;
7250}

7252static long long
7253_cairo_pdf_surface_write_xref (cairo_pdf_surface_t *surface)
7254{
  cairo_pdf_object_t *object;
  int num_objects, i;
  long long offset;

  num_objects = _cairo_array_num_elements (&surface->objects);

  offset = _cairo_output_stream_get_position (surface->output);
  _cairo_output_stream_printf (surface->output,
		 "xref\n"
		 "%d %d\n",
		 0, num_objects + 1);

  _cairo_output_stream_printf (surface->output,
		 "0000000000 65535 f \n");
  for (i = 0; i < num_objects; i++) {
object = _cairo_array_index (&surface->objects, i);
_cairo_output_stream_printf (surface->output,
		     "%010lld 00000 n \n", object->u.offset);
  }

  return offset;
7276}

7278static void
7279_cairo_write_xref_stream_entry (cairo_output_stream_t *stream,
		int                    id,
		int                    type,
		int                    field2_size,
		long long              field2,
		int                    field3,
		cairo_bool_t           write_as_comments)
7286{
  char buf[20];
  int i;

  if (write_as_comments) {
_cairo_output_stream_printf (stream, "%% %5d %2d %10lld  %d\n", id, type, field2, field3);
  } else {
/* Each field is big endian */
buf[0] = type; /* field 1 */
for (i = field2_size - 1; i >= 0; i--) {
   buf[i + 1] = field2 & 0xff;
   field2 >>= 8;
}
buf[field2_size + 1] = field3 >> 8;
buf[field2_size + 2] = field3 & 0xff;
_cairo_output_stream_write (stream, buf, field2_size + 3);
  }
7303}

7305static void
7306_cairo_write_xref_stream_entries (cairo_pdf_surface_t   *surface,
		  cairo_output_stream_t *stream,
		  int                    field2_size,
		  cairo_bool_t           write_as_comments)
7310{
  cairo_pdf_object_t *object;
  int num_objects, i;

  /* PDF requires this to be first entry */
  _cairo_write_xref_stream_entry (stream,
		    0,
		    PDF_OBJECT_FREE,
		    field2_size,
		    0, /* next free object number */
		    0xffff, /* next generation number */
		    write_as_comments);

  num_objects = _cairo_array_num_elements (&surface->objects);
  for (i = 0; i < num_objects; i++) {
object = _cairo_array_index (&surface->objects, i);
if (object->type == PDF_OBJECT_UNCOMPRESSED) {
   _cairo_write_xref_stream_entry (stream,
			    i + 1,
			    object->type,
			    field2_size,
			    object->u.offset,
			    0, /* generation number */
			    write_as_comments);
} else if (object->type == PDF_OBJECT_COMPRESSED) {
   _cairo_write_xref_stream_entry (stream,
			    i + 1,
			    object->type,
			    field2_size,
			    object->u.compressed_obj.xref_stream.id,
			    object->u.compressed_obj.index,
			    write_as_comments);
} else {
   _cairo_write_xref_stream_entry (stream,
			    i + 1,
			    PDF_OBJECT_FREE,
			    field2_size,
			    0,
			    0xffff,
			    write_as_comments);
}
  }
7352}

7354static cairo_int_status_t
7355_cairo_pdf_surface_write_xref_stream (cairo_pdf_surface_t  *surface,
		      cairo_pdf_resource_t  xref_res,
		      cairo_pdf_resource_t  root_res,
		      cairo_pdf_resource_t  info_res,
		      long long            *xref_offset)
7360{
  cairo_output_stream_t *mem_stream;
  cairo_output_stream_t *xref_stream;
  long long offset;
  int offset_bytes;
  cairo_status_t status;

  *xref_offset = _cairo_output_stream_get_position (surface->output);

  /* Find the minimum number of bytes required to represent offsets in the generated file (up to this point). */
  offset_bytes = 0;
  offset = *xref_offset;
  while (offset > 0) {
offset >>= 8;
offset_bytes++;
  }

  mem_stream = _cairo_memory_stream_create ();
  xref_stream = _cairo_deflate_stream_create (mem_stream);
  _cairo_write_xref_stream_entries (surface, xref_stream, offset_bytes, FALSE0);

  status = _cairo_output_stream_destroy (xref_stream);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_pdf_surface_update_object (surface, xref_res);
  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /Type /XRef\n"
		 "   /Length %d\n"
		 "   /Filter /FlateDecode\n"
		 "   /Size %d\n"
		 "   /W [1 %d 2]\n"
		 "   /Root %d 0 R\n"
		 "   /Info %d 0 R\n"
		 ">>\n",
		 xref_res.id,
		 _cairo_memory_stream_length (mem_stream),
		 surface->next_available_resource.id,
		 offset_bytes,
		 root_res.id,
		 info_res.id);

  if (!surface->compress_streams) {
/* Adobe Reader requires xref streams to be flate encoded (PDF
* Reference 1.7, implementation note 20). This means
* compression must always be enabled on this stream. To
* facilitate debugging when compress_stream is disabled, emit
* a human readable format of the xref stream as PDF comments.
*/
_cairo_output_stream_printf (surface->output,
		     "%%   id   type  offset/obj  gen/index\n");
_cairo_write_xref_stream_entries (surface, surface->output, offset_bytes, TRUE1);
  }

  _cairo_output_stream_printf (surface->output,
		 "stream\n");
  _cairo_memory_stream_copy (mem_stream, surface->output);
  status = _cairo_output_stream_destroy (mem_stream);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_output_stream_printf (surface->output,
		 "\n"
		 "endstream\n"
		 "endobj\n");

  return _cairo_output_stream_get_status (surface->output);
7428}

7430static cairo_int_status_t
7431_cairo_pdf_surface_write_mask_group (cairo_pdf_surface_t	*surface,
		     cairo_pdf_smask_group_t	*group)
7433{
  cairo_pdf_resource_t mask_group;
  cairo_pdf_resource_t smask;
  cairo_pdf_smask_group_t *smask_group;
  cairo_pdf_resource_t pattern_res, gstate_res;
  cairo_int_status_t status;
  cairo_box_double_t bbox;

  /* Create mask group */
  _get_bbox_from_extents (&group->extents, &bbox);
  status = _cairo_pdf_surface_open_group (surface, &bbox, NULL((void*)0));
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (_can_paint_pattern (group->mask)) {
_cairo_output_stream_printf (surface->output, "q\n");
status = _cairo_pdf_surface_paint_pattern (surface,
				   CAIRO_OPERATOR_OVER,
				   group->mask,
				   CAIRO_ANALYSIS_MASK_MASK,
				   &group->extents,
				   1.0, /* alpha */
				   FALSE0); /* mask */
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

_cairo_output_stream_printf (surface->output, "Q\n");
  } else {
pattern_res.id = 0;
gstate_res.id = 0;
status = _cairo_pdf_surface_add_pdf_pattern (surface, group->mask,
				     CAIRO_OPERATOR_OVER,
				     CAIRO_ANALYSIS_MASK_MASK,
				     NULL((void*)0),
				     &pattern_res, &gstate_res);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

if (gstate_res.id != 0) {
   smask_group = _cairo_pdf_surface_create_smask_group (surface, &group->extents);
   if (unlikely (smask_group == NULL)(__builtin_expect (!!(smask_group == ((void*)0)), 0)))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

   smask_group->width = group->width;
   smask_group->height = group->height;
   smask_group->operation = PDF_PAINT;
   smask_group->source = cairo_pattern_reference_moz_cairo_pattern_reference (group->mask);
   smask_group->source_res = pattern_res;
   status = _cairo_pdf_surface_add_smask_group (surface, smask_group);
   if (unlikely (status)(__builtin_expect (!!(status), 0))) {
_cairo_pdf_smask_group_destroy (smask_group);
return status;
   }

   status = _cairo_pdf_surface_add_smask (surface, gstate_res);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

   status = _cairo_pdf_surface_add_xobject (surface, smask_group->group_res);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

   _cairo_output_stream_printf (surface->output,
			 "q /s%d gs /x%d Do Q\n",
			 gstate_res.id,
			 smask_group->group_res.id);
} else {
   status = _cairo_pdf_surface_select_pattern (surface, group->mask, pattern_res, FALSE0);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

   _cairo_output_stream_printf (surface->output,
			 "%f %f %f %f re f\n",
			 bbox.p1.x,
			 bbox.p1.y,
			 bbox.p2.x - bbox.p1.x,
			 bbox.p2.y - bbox.p1.y);

   status = _cairo_pdf_surface_unselect_pattern (surface);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;
}
  }

  status = _cairo_pdf_surface_close_group (surface, &mask_group);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  /* Create source group */
  status = _cairo_pdf_surface_open_group (surface, &bbox, &group->source_res);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (_can_paint_pattern (group->source)) {
_cairo_output_stream_printf (surface->output, "q\n");
status = _cairo_pdf_surface_paint_pattern (surface,
				   CAIRO_OPERATOR_OVER,
				   group->source,
				   CAIRO_ANALYSIS_MASK_MASK,
				   &group->extents,
				   1.0, /* alpha */
				   FALSE0); /* mask */
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

_cairo_output_stream_printf (surface->output, "Q\n");
  } else {
pattern_res.id = 0;
gstate_res.id = 0;
status = _cairo_pdf_surface_add_pdf_pattern (surface, group->source,
				     CAIRO_OPERATOR_OVER,
				     CAIRO_ANALYSIS_MASK_MASK,
				     NULL((void*)0),
				     &pattern_res, &gstate_res);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

if (gstate_res.id != 0) {
   smask_group = _cairo_pdf_surface_create_smask_group (surface, &group->extents);
   if (unlikely (smask_group == NULL)(__builtin_expect (!!(smask_group == ((void*)0)), 0)))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

   smask_group->operation = PDF_PAINT;
   smask_group->source = cairo_pattern_reference_moz_cairo_pattern_reference (group->source);
   smask_group->source_res = pattern_res;
   status = _cairo_pdf_surface_add_smask_group (surface, smask_group);
   if (unlikely (status)(__builtin_expect (!!(status), 0))) {
_cairo_pdf_smask_group_destroy (smask_group);
return status;
   }

   status = _cairo_pdf_surface_add_smask (surface, gstate_res);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

   status = _cairo_pdf_surface_add_xobject (surface, smask_group->group_res);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

   _cairo_output_stream_printf (surface->output,
			 "q /s%d gs /x%d Do Q\n",
			 gstate_res.id,
			 smask_group->group_res.id);
} else {
   status = _cairo_pdf_surface_select_pattern (surface, group->source, pattern_res, FALSE0);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

   _cairo_output_stream_printf (surface->output,
			 "%f %f %f %f re f\n",
			 bbox.p1.x,
			 bbox.p1.y,
			 bbox.p2.x - bbox.p1.x,
			 bbox.p2.y - bbox.p1.y);

   status = _cairo_pdf_surface_unselect_pattern (surface);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;
}
  }

  status = _cairo_pdf_surface_close_group (surface, NULL((void*)0));
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  /* Create an smask based on the alpha component of mask_group */
  smask = _cairo_pdf_surface_new_object (surface);
  if (smask.id == 0)
return _cairo_error (CAIRO_STATUS_NO_MEMORY);

  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /Type /Mask\n"
		 "   /S /Alpha\n"
		 "   /G %d 0 R\n"
		 ">>\n"
		 "endobj\n",
		 smask.id,
		 mask_group.id);

  /* Create a GState that uses the smask */
  _cairo_pdf_surface_update_object (surface, group->group_res);
  _cairo_output_stream_printf (surface->output,
		 "%d 0 obj\n"
		 "<< /Type /ExtGState\n"
		 "   /SMask %d 0 R\n"
		 "   /ca 1\n"
		 "   /CA 1\n"
		 "   /AIS false\n"
		 ">>\n"
		 "endobj\n",
		 group->group_res.id,
		 smask.id);

  return _cairo_output_stream_get_status (surface->output);
7628}

7630static cairo_int_status_t
7631_cairo_pdf_surface_write_smask_group (cairo_pdf_surface_t     *surface,
		      cairo_pdf_smask_group_t *group)
7633{
  double old_width, old_height;
  cairo_bool_t old_in_xobject;
  cairo_int_status_t status;
  cairo_box_double_t bbox;
  cairo_rectangle_int_t old_surface_extents;

  old_width = surface->width;
  old_height = surface->height;
  old_surface_extents = surface->surface_extents;
  old_in_xobject = surface->in_xobject;
  surface->in_xobject = TRUE1;
  _cairo_pdf_surface_set_size_internal (surface,
			  group->width,
			  group->height);
  _cairo_pdf_operators_reset (&surface->pdf_operators);
  /* _mask is a special case that requires two groups - source
   * and mask as well as a smask and gstate dictionary */
  if (group->operation == PDF_MASK) {
status = _cairo_pdf_surface_write_mask_group (surface, group);
goto RESTORE_SIZE;
  }

  _get_bbox_from_extents (&group->extents, &bbox);
  status = _cairo_pdf_surface_open_group (surface, &bbox, &group->group_res);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  status = _cairo_pdf_surface_select_pattern (surface,
				group->source,
				group->source_res,
				group->operation == PDF_STROKE);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  switch (group->operation) {
  case PDF_PAINT:
_cairo_output_stream_printf (surface->output,
		     "0 0 %f %f re f\n",
		     surface->width, surface->height);
break;
  case PDF_MASK:
ASSERT_NOT_REACHEDdo { ((void) sizeof (__assert_single_arg (!"reached")), __extension__
 ({ if (!"reached") ; else __assert_fail ("!\"reached\"", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 7675, __extension__ __PRETTY_FUNCTION__); })); } while (0);
break;
  case PDF_FILL:
status = _cairo_pdf_operators_fill (&surface->pdf_operators,
			    &group->path,
			    group->fill_rule);
break;
  case PDF_STROKE:
status = _cairo_pdf_operators_stroke (&surface->pdf_operators,
			      &group->path,
			      &group->style,
			      &group->ctm,
			      &group->ctm_inverse);
break;
  case PDF_SHOW_GLYPHS:
status = _cairo_pdf_operators_show_text_glyphs (&surface->pdf_operators,
					group->utf8, group->utf8_len,
					group->glyphs, group->num_glyphs,
					group->clusters, group->num_clusters,
					group->cluster_flags,
					group->scaled_font);
break;
  }
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  status = _cairo_pdf_surface_unselect_pattern (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  status = _cairo_pdf_surface_close_group (surface, NULL((void*)0));

7707RESTORE_SIZE:
  surface->in_xobject = old_in_xobject;
  _cairo_pdf_surface_set_size_internal (surface,
			  old_width,
			  old_height);
  surface->surface_extents = old_surface_extents;
  _cairo_pdf_operators_reset (&surface->pdf_operators);

  return status;
7716}

7718static cairo_int_status_t
7719_cairo_pdf_surface_write_patterns_and_smask_groups (cairo_pdf_surface_t *surface,
				    cairo_bool_t         finish)
7721{
  cairo_pdf_pattern_t pattern;
  cairo_pdf_smask_group_t *group;
  cairo_pdf_source_surface_t src_surface;
  unsigned int pattern_index, group_index, surface_index, doc_surface_index;
  cairo_int_status_t status;
  cairo_bool_t is_image;

  /* Writing out PDF_MASK groups will cause additional smask groups
   * to be appended to surface->smask_groups. Additional patterns
   * may also be appended to surface->patterns.
   *
   * Writing recording surface patterns will cause additional patterns
   * and groups to be appended.
   */
  pattern_index = 0;
  group_index = 0;
  surface_index = 0;
  doc_surface_index = 0;
  while ((pattern_index < _cairo_array_num_elements (&surface->page_patterns)) ||
  (group_index < _cairo_array_num_elements (&surface->smask_groups)) ||
  (surface_index < _cairo_array_num_elements (&surface->page_surfaces)) ||
  (finish && (doc_surface_index < _cairo_array_num_elements (&surface->doc_surfaces))))
  {
for (; group_index < _cairo_array_num_elements (&surface->smask_groups); group_index++) {
   _cairo_array_copy_element (&surface->smask_groups, group_index, &group);
   status = _cairo_pdf_surface_write_smask_group (surface, group);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;
}

for (; pattern_index < _cairo_array_num_elements (&surface->page_patterns); pattern_index++) {
   _cairo_array_copy_element (&surface->page_patterns, pattern_index, &pattern);
   status = _cairo_pdf_surface_emit_pattern (surface, &pattern);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;
}

for (; surface_index < _cairo_array_num_elements (&surface->page_surfaces); surface_index++) {
   _cairo_array_copy_element (&surface->page_surfaces, surface_index, &src_surface);
   status = _cairo_pdf_surface_emit_surface (surface, &src_surface, FALSE0, &is_image);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;
}

if (finish) {
   for (; doc_surface_index < _cairo_array_num_elements (&surface->doc_surfaces); doc_surface_index++) {
_cairo_array_copy_element (&surface->doc_surfaces, doc_surface_index, &src_surface);
status = _cairo_pdf_surface_emit_surface (surface, &src_surface, FALSE0, &is_image);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
    return status;
   }
}
  }

  return CAIRO_STATUS_SUCCESS;
7777}

7779static cairo_int_status_t
7780_cairo_pdf_surface_write_page (cairo_pdf_surface_t *surface)
7781{
  cairo_pdf_resource_t knockout, res;
  cairo_int_status_t status;
  unsigned int i, len;
  cairo_pdf_page_info_t *page_info;

  page_info = _cairo_array_last_element (&surface->pages);

  status = _cairo_pdf_surface_open_object_stream (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  status = _cairo_pdf_interchange_write_page_objects (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_pdf_group_resources_clear (&surface->resources);
  if (surface->has_fallback_images) {
cairo_rectangle_int_t extents;
cairo_box_double_t    bbox;

extents.x = 0;
extents.y = 0;
extents.width = ceil (surface->width);
extents.height = ceil (surface->height);
_get_bbox_from_extents (&extents, &bbox);
status = _cairo_pdf_surface_open_knockout_group (surface, &bbox);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

len = _cairo_array_num_elements (&surface->knockout_group);
for (i = 0; i < len; i++) {
   _cairo_array_copy_element (&surface->knockout_group, i, &res);
   _cairo_output_stream_printf (surface->output,
			 "/x%d Do\n",
			 res.id);
   status = _cairo_pdf_surface_add_xobject (surface, res);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;
}
_cairo_output_stream_printf (surface->output,
		     "/x%d Do\n",
		     surface->content.id);
status = _cairo_pdf_surface_add_xobject (surface, surface->content);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

status = _cairo_pdf_surface_close_group (surface, &knockout);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

_cairo_pdf_group_resources_clear (&surface->resources);
status = _cairo_pdf_surface_open_content_stream (surface, NULL((void*)0), NULL((void*)0), FALSE0, FALSE0, -1);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

_cairo_output_stream_printf (surface->output,
		     "/x%d Do\n",
		     knockout.id);
status = _cairo_pdf_surface_add_xobject (surface, knockout);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;

status = _cairo_pdf_surface_close_content_stream (surface, FALSE0);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;
  }

  if (surface->thumbnail_image) {
cairo_pdf_source_surface_entry_t entry;

memset (&entry, 0, sizeof (entry));
page_info->thumbnail = _cairo_pdf_surface_new_object (surface);
entry.surface_res = page_info->thumbnail;
_cairo_pdf_surface_emit_image (surface, surface->thumbnail_image, &entry);
  }

  page_info->content = surface->content;
  page_info->resources = surface->content_resources;
  page_info->struct_parents = surface->page_parent_tree;

  status = _cairo_pdf_surface_write_patterns_and_smask_groups (surface, FALSE0);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  return _cairo_pdf_surface_close_object_stream (surface);
7867}

7869static cairo_int_status_t
7870_cairo_pdf_surface_analyze_surface_pattern_transparency (cairo_pdf_surface_t      *surface,
					 cairo_surface_pattern_t  *pattern)
7872{
  cairo_image_surface_t  *image;
  void		   *image_extra;
  cairo_int_status_t      status;
  cairo_image_transparency_t transparency;

  status = _cairo_surface_acquire_source_image (pattern->surface,
				  &image,
				  &image_extra);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

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

  transparency = _cairo_image_analyze_transparency (image);
  if (transparency == CAIRO_IMAGE_IS_OPAQUE)
status = CAIRO_STATUS_SUCCESS;
  else
status = CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY;

  _cairo_surface_release_source_image (pattern->surface, image, image_extra);

  return status;
7896}

7898static cairo_bool_t
7899_surface_pattern_supported (cairo_surface_pattern_t *pattern)
7900{
  cairo_extend_t extend;

  if (pattern->surface->type == CAIRO_SURFACE_TYPE_RECORDING)
return TRUE1;

  if (pattern->surface->backend->acquire_source_image == NULL((void*)0))
return FALSE0;

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

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

  extend = cairo_pattern_get_extend_moz_cairo_pattern_get_extend (&pattern->base);
  switch (extend) {
  case CAIRO_EXTEND_NONE:
  case CAIRO_EXTEND_REPEAT:
  case CAIRO_EXTEND_REFLECT:
  /* There's no point returning FALSE for EXTEND_PAD, as the image
   * surface does not currently implement it either */
  case CAIRO_EXTEND_PAD:
return TRUE1;
  }

  ASSERT_NOT_REACHEDdo { ((void) sizeof (__assert_single_arg (!"reached")), __extension__
 ({ if (!"reached") ; else __assert_fail ("!\"reached\"", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 7928, __extension__ __PRETTY_FUNCTION__); })); } while (0);
  return FALSE0;
7930}

7932static cairo_bool_t
7933_pattern_supported (const cairo_pattern_t *pattern)
7934{
  switch (pattern->type) {
  case CAIRO_PATTERN_TYPE_SOLID:
  case CAIRO_PATTERN_TYPE_LINEAR:
  case CAIRO_PATTERN_TYPE_RADIAL:
  case CAIRO_PATTERN_TYPE_MESH:
  case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
return TRUE1;

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

  default:
ASSERT_NOT_REACHEDdo { ((void) sizeof (__assert_single_arg (!"reached")), __extension__
 ({ if (!"reached") ; else __assert_fail ("!\"reached\"", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 7947, __extension__ __PRETTY_FUNCTION__); })); } while (0);
return FALSE0;
  }
7950}

7952static cairo_bool_t
7953_pdf_operator_supported (cairo_operator_t op)
7954{
  switch (op) {
  case CAIRO_OPERATOR_OVER:
  case CAIRO_OPERATOR_MULTIPLY:
  case CAIRO_OPERATOR_SCREEN:
  case CAIRO_OPERATOR_OVERLAY:
  case CAIRO_OPERATOR_DARKEN:
  case CAIRO_OPERATOR_LIGHTEN:
  case CAIRO_OPERATOR_COLOR_DODGE:
  case CAIRO_OPERATOR_COLOR_BURN:
  case CAIRO_OPERATOR_HARD_LIGHT:
  case CAIRO_OPERATOR_SOFT_LIGHT:
  case CAIRO_OPERATOR_DIFFERENCE:
  case CAIRO_OPERATOR_EXCLUSION:
  case CAIRO_OPERATOR_HSL_HUE:
  case CAIRO_OPERATOR_HSL_SATURATION:
  case CAIRO_OPERATOR_HSL_COLOR:
  case CAIRO_OPERATOR_HSL_LUMINOSITY:
return TRUE1;

  default:
  case CAIRO_OPERATOR_CLEAR:
  case CAIRO_OPERATOR_SOURCE:
  case CAIRO_OPERATOR_IN:
  case CAIRO_OPERATOR_OUT:
  case CAIRO_OPERATOR_ATOP:
  case CAIRO_OPERATOR_DEST:
  case CAIRO_OPERATOR_DEST_OVER:
  case CAIRO_OPERATOR_DEST_IN:
  case CAIRO_OPERATOR_DEST_OUT:
  case CAIRO_OPERATOR_DEST_ATOP:
  case CAIRO_OPERATOR_XOR:
  case CAIRO_OPERATOR_ADD:
  case CAIRO_OPERATOR_SATURATE:
return FALSE0;
  }
7990}

7992static cairo_int_status_t
7993_cairo_pdf_surface_analyze_operation (cairo_pdf_surface_t  *surface,
		      cairo_operator_t      op,
		      const cairo_pattern_t      *pattern,
		      const cairo_rectangle_int_t	 *extents)
7997{
  if (surface->force_fallbacks &&
surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE)
  {
return CAIRO_INT_STATUS_UNSUPPORTED;
  }

  if (! _pattern_supported (pattern))
return CAIRO_INT_STATUS_UNSUPPORTED;

  if (_pdf_operator_supported (op)) {
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((void*)0));
    _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.x) > 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;
   }
}

return CAIRO_STATUS_SUCCESS;
  }


  /* The SOURCE operator is supported if the pattern is opaque or if
   * there is nothing painted underneath. */
  if (op == CAIRO_OPERATOR_SOURCE) {
if (surface->type3_replay)
   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 (_cairo_pattern_is_opaque (pattern, extents)) {
    return CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN;
} else {
    /* FIXME: The analysis surface does not yet have
     * the capability to analyze a non opaque recording
     * surface and mark it supported if there is
     * nothing underneath. For now recording surfaces of
     * type CONTENT_COLOR_ALPHA painted with
     * OPERATOR_SOURCE will result in a fallback
     * image. */

    return CAIRO_INT_STATUS_UNSUPPORTED;
}
   } else {
return _cairo_pdf_surface_analyze_surface_pattern_transparency (surface,
								surface_pattern);
   }
}

if (_cairo_pattern_is_opaque (pattern, extents))
   return CAIRO_STATUS_SUCCESS;
else
   return CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY;
  }

  return CAIRO_INT_STATUS_UNSUPPORTED;
8077}

8079static cairo_bool_t
8080_cairo_pdf_surface_operation_supported (cairo_pdf_surface_t  *surface,
			cairo_operator_t      op,
			const cairo_pattern_t      *pattern,
			const cairo_rectangle_int_t *extents)
8084{
  return _cairo_pdf_surface_analyze_operation (surface, op, pattern, extents) != CAIRO_INT_STATUS_UNSUPPORTED;
8086}

8088static cairo_int_status_t
8089_cairo_pdf_surface_start_fallback (cairo_pdf_surface_t *surface)
8090{
  cairo_box_double_t bbox;
  cairo_int_status_t status;

  status = _cairo_pdf_surface_close_content_stream (surface, FALSE0);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  status = _cairo_array_append (&surface->knockout_group, &surface->content);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_pdf_group_resources_clear (&surface->resources);
  bbox.p1.x = 0;
  bbox.p1.y = 0;
  bbox.p2.x = surface->width;
  bbox.p2.y = surface->height;
  status = _cairo_pdf_surface_open_content_stream (surface, &bbox, NULL((void*)0), TRUE1, TRUE1, -1);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  return _cairo_pdf_interchange_begin_page_content (surface);
8112}

8114/* If source is an opaque image and mask is an image and both images
* have the same bounding box we can emit them as a image/smask pair.
*/
8117static cairo_int_status_t
8118_cairo_pdf_surface_emit_combined_smask (cairo_pdf_surface_t         *surface,
			cairo_operator_t	     op,
			const cairo_pattern_t       *source,
			const cairo_pattern_t       *mask,
			const cairo_rectangle_int_t *extents)
8123{
  cairo_int_status_t status;
  cairo_image_surface_t  *image;
  void		   *image_extra;
  cairo_image_transparency_t transparency;
  int src_width, src_height;
  int mask_width, mask_height;
  double src_x_offset, src_y_offset;
  double mask_x_offset, mask_y_offset;
  double src_x1, src_y1, src_x2, src_y2;
  double mask_x1, mask_y1, mask_x2, mask_y2;
  cairo_matrix_t p2u;
  double src_radius, mask_radius, e;
  cairo_bool_t need_smask;
  cairo_pdf_source_surface_entry_t *pdf_source;

  /* Check that source and mask are images */

  if (!((source->type == CAIRO_PATTERN_TYPE_SURFACE || source->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE) &&
 (mask->type == CAIRO_PATTERN_TYPE_SURFACE || mask->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE)))
return CAIRO_INT_STATUS_UNSUPPORTED;

  if (source->type == CAIRO_PATTERN_TYPE_SURFACE &&
((cairo_surface_pattern_t *) source)->surface->type == CAIRO_SURFACE_TYPE_RECORDING)
  {
return CAIRO_INT_STATUS_UNSUPPORTED;
  }

  if (mask->type == CAIRO_PATTERN_TYPE_SURFACE &&
((cairo_surface_pattern_t *) mask)->surface->type == CAIRO_SURFACE_TYPE_RECORDING)
  {
return CAIRO_INT_STATUS_UNSUPPORTED;
  }

  if (source->extend != CAIRO_EXTEND_NONE || mask->extend != CAIRO_EXTEND_NONE)
return CAIRO_INT_STATUS_UNSUPPORTED;

  /* Check that source is opaque and get image sizes */

  status = _cairo_pdf_surface_acquire_source_image_from_pattern (surface, source,
						   &image, &image_extra);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

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

  src_width = image->width;
  src_height = image->height;
  if (source->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE) {
cairo_surface_get_device_offset_moz_cairo_surface_get_device_offset (&image->base, &src_x_offset, &src_y_offset);
  } else {
src_x_offset = 0;
src_y_offset = 0;
  }

  transparency = _cairo_image_analyze_transparency (image);
  _cairo_pdf_surface_release_source_image_from_pattern (surface, source, image, image_extra);

  if (transparency != CAIRO_IMAGE_IS_OPAQUE)
return CAIRO_INT_STATUS_UNSUPPORTED;

  status = _cairo_pdf_surface_acquire_source_image_from_pattern (surface, mask,
						   &image, &image_extra);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

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

  mask_width = image->width;
  mask_height = image->height;
  if (mask->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE) {
cairo_surface_get_device_offset_moz_cairo_surface_get_device_offset (&image->base, &mask_x_offset, &mask_y_offset);
  } else {
mask_x_offset = 0;
mask_y_offset = 0;
  }

  transparency = _cairo_image_analyze_transparency (image);
  need_smask = transparency != CAIRO_IMAGE_IS_OPAQUE;

  _cairo_pdf_surface_release_source_image_from_pattern (surface, mask, image, image_extra);

  /* Check that both images have the same extents with a tolerance
   * of half the smallest source pixel. */

  p2u = source->matrix;
  status = cairo_matrix_invert_moz_cairo_matrix_invert (&p2u);
  /* cairo_pattern_set_matrix ensures the matrix is invertible */
  assert (status == CAIRO_INT_STATUS_SUCCESS)((void) sizeof (__assert_single_arg (status == CAIRO_INT_STATUS_SUCCESS
)), __extension__ ({ if (status == CAIRO_INT_STATUS_SUCCESS) ;
 else __assert_fail ("status == CAIRO_INT_STATUS_SUCCESS", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 8213, __extension__ __PRETTY_FUNCTION__); }));
  src_x1 = 0;
  src_y1 = 0;
  src_x2 = src_width;
  src_y2 = src_height;
  cairo_matrix_transform_point_moz_cairo_matrix_transform_point (&p2u, &src_x1, &src_y1);
  cairo_matrix_transform_point_moz_cairo_matrix_transform_point (&p2u, &src_x2, &src_y2);
  src_radius = _cairo_matrix_transformed_circle_major_axis (&p2u, 0.5);

  p2u = mask->matrix;
  status = cairo_matrix_invert_moz_cairo_matrix_invert (&p2u);
  /* cairo_pattern_set_matrix ensures the matrix is invertible */
  assert (status == CAIRO_INT_STATUS_SUCCESS)((void) sizeof (__assert_single_arg (status == CAIRO_INT_STATUS_SUCCESS
)), __extension__ ({ if (status == CAIRO_INT_STATUS_SUCCESS) ;
 else __assert_fail ("status == CAIRO_INT_STATUS_SUCCESS", "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 8225, __extension__ __PRETTY_FUNCTION__); }));
  mask_x1 = 0;
  mask_y1 = 0;
  mask_x2 = mask_width;
  mask_y2 = mask_height;
  cairo_matrix_transform_point_moz_cairo_matrix_transform_point (&p2u, &mask_x1, &mask_y1);
  cairo_matrix_transform_point_moz_cairo_matrix_transform_point (&p2u, &mask_x2, &mask_y2);
  mask_radius = _cairo_matrix_transformed_circle_major_axis (&p2u, 0.5);

  if (src_radius < mask_radius)
e = src_radius;
  else
e = mask_radius;

  if (fabs(src_x1 - mask_x1) > e ||
fabs(src_x2 - mask_x2) > e ||
fabs(src_y1 - mask_y1) > e ||
fabs(src_y2 - mask_y2) > e)
return CAIRO_INT_STATUS_UNSUPPORTED;

  /* Check both images have same device offset */
  if (fabs(src_x_offset - mask_x_offset) > e ||
fabs(src_y_offset - mask_y_offset) > e)
return CAIRO_INT_STATUS_UNSUPPORTED;

  if (need_smask) {
status = _cairo_pdf_surface_add_source_surface (surface,
					NULL((void*)0),
					mask,
					-1, /* node_surface_index */
					op,
					source->filter,
					FALSE0, /* stencil mask */
					TRUE1, /* smask */
					FALSE0, /* need_transp_group */
					extents,
					NULL((void*)0), /* smask_res */
					&pdf_source,
					NULL((void*)0),
					NULL((void*)0),
					NULL((void*)0));
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   return status;
  }

  status = _cairo_pdf_operators_flush (&surface->pdf_operators);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_output_stream_printf (surface->output, "q\n");
  status = _cairo_pdf_surface_paint_surface_pattern (surface, op, source,
				       CAIRO_ANALYSIS_SOURCE_NONE,
				       extents,
				       1.0, /* alpha */
				       need_smask ? &pdf_source->surface_res : NULL((void*)0),
				       FALSE0);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

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

  status = _cairo_output_stream_get_status (surface->output);


  return status;
8290}

8292/* A PDF stencil mask is an A1 mask used with the current color */
8293static cairo_int_status_t
8294_cairo_pdf_surface_emit_stencil_mask (cairo_pdf_surface_t         *surface,
		      cairo_operator_t	           op,
		      const cairo_pattern_t       *source,
		      const cairo_pattern_t       *mask,
		      const cairo_rectangle_int_t *extents)
8299{
  cairo_int_status_t status;
  cairo_image_surface_t  *image;
  void		   *image_extra;
  cairo_image_transparency_t transparency;
  cairo_pdf_resource_t pattern_res = {0};

  if (! (source->type == CAIRO_PATTERN_TYPE_SOLID &&
  (mask->type == CAIRO_PATTERN_TYPE_SURFACE || mask->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE)))
return CAIRO_INT_STATUS_UNSUPPORTED;

  if (mask->type == CAIRO_PATTERN_TYPE_SURFACE &&
((cairo_surface_pattern_t *) mask)->surface->type == CAIRO_SURFACE_TYPE_RECORDING)
  {
return CAIRO_INT_STATUS_UNSUPPORTED;
  }

  status = _cairo_pdf_surface_acquire_source_image_from_pattern (surface, mask,
						   &image, &image_extra);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

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

  transparency = _cairo_image_analyze_transparency (image);
  if (transparency != CAIRO_IMAGE_IS_OPAQUE &&
transparency != CAIRO_IMAGE_HAS_BILEVEL_ALPHA)
  {
status = CAIRO_INT_STATUS_UNSUPPORTED;
goto cleanup;
  }

  status = _cairo_pdf_surface_select_pattern (surface, source,
				pattern_res, FALSE0);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  status = _cairo_pdf_operators_flush (&surface->pdf_operators);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  _cairo_output_stream_printf (surface->output, "q\n");
  status = _cairo_pdf_surface_paint_surface_pattern (surface, op, mask,
				       CAIRO_ANALYSIS_SOURCE_NONE,
				       extents, 1.0, NULL((void*)0), TRUE1);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

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

  status = _cairo_output_stream_get_status (surface->output);

8352cleanup:
  _cairo_pdf_surface_release_source_image_from_pattern (surface, mask, image, image_extra);

  return status;
8356}

8358static cairo_int_status_t
8359_cairo_pdf_surface_set_clip (cairo_pdf_surface_t *surface,
	     cairo_composite_rectangles_t *composite)
8361{
  cairo_clip_t *clip = composite->clip;

  if (_cairo_composite_rectangles_can_reduce_clip (composite, clip))
clip = NULL((void*)0);

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

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

8376static cairo_int_status_t
8377_cairo_pdf_surface_paint (void			*abstract_surface,
	  cairo_operator_t	 op,
	  const cairo_pattern_t	*source,
	  const cairo_clip_t	*clip)
8381{
  cairo_pdf_surface_t *surface = abstract_surface;
  cairo_pdf_smask_group_t *group;
  cairo_pdf_resource_t pattern_res, gstate_res;
  cairo_composite_rectangles_t extents;
  cairo_int_status_t status;

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

  status = _cairo_pdf_interchange_add_operation_extents (surface, &extents.bounded);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) {
status = _cairo_pdf_surface_analyze_operation (surface, op, source, &extents.bounded);
goto cleanup;
  } else if (surface->paginated_mode == CAIRO_PAGINATED_MODE_FALLBACK) {
status = _cairo_pdf_surface_start_fallback  (surface);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;
  }

  assert (_cairo_pdf_surface_operation_supported (surface, op, source, &extents.bounded))((void) sizeof (__assert_single_arg (_cairo_pdf_surface_operation_supported
 (surface, op, source, &extents.bounded))), __extension__
 ({ if (_cairo_pdf_surface_operation_supported (surface, op, source
, &extents.bounded)) ; else __assert_fail ("_cairo_pdf_surface_operation_supported (surface, op, source, &extents.bounded)"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 8407, __extension__ __PRETTY_FUNCTION__); }));

  status = _cairo_pdf_surface_set_clip (surface, &extents);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  status = _cairo_pdf_surface_select_operator (surface, op);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  status = _cairo_pdf_operators_flush (&surface->pdf_operators);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  if (_can_paint_pattern (source)) {
_cairo_output_stream_printf (surface->output, "q\n");
status = _cairo_pdf_surface_paint_pattern (surface,
				   op,
				   source,
				   CAIRO_ANALYSIS_SOURCE_PAINT,
				   &extents.bounded,
				   1.0, /* alpha */
				   FALSE0); /* mask */
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

_cairo_output_stream_printf (surface->output, "Q\n");
_cairo_composite_rectangles_fini (&extents);
return _cairo_output_stream_get_status (surface->output);
  }

  pattern_res.id = 0;
  gstate_res.id = 0;
  status = _cairo_pdf_surface_add_pdf_pattern (surface, source, op,
				 CAIRO_ANALYSIS_SOURCE_PAINT,
				 &extents.bounded,
				 &pattern_res, &gstate_res);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  if (gstate_res.id != 0) {
group = _cairo_pdf_surface_create_smask_group (surface, &extents.bounded);
if (unlikely (group == NULL)(__builtin_expect (!!(group == ((void*)0)), 0))) {
   status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
   goto cleanup;
}

group->operation = PDF_PAINT;
status = _cairo_pattern_create_copy (&group->source, source);
if (unlikely (status)(__builtin_expect (!!(status), 0))) {
   _cairo_pdf_smask_group_destroy (group);
   goto cleanup;
}
group->source_res = pattern_res;
status = _cairo_pdf_surface_add_smask_group (surface, group);
if (unlikely (status)(__builtin_expect (!!(status), 0))) {
   _cairo_pdf_smask_group_destroy (group);
   goto cleanup;
}

status = _cairo_pdf_surface_add_smask (surface, gstate_res);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

status = _cairo_pdf_surface_add_xobject (surface, group->group_res);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

_cairo_output_stream_printf (surface->output,
		     "q /s%d gs /x%d Do Q\n",
		     gstate_res.id,
		     group->group_res.id);
  } else {
status = _cairo_pdf_surface_select_pattern (surface, source,
				    pattern_res, FALSE0);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

_cairo_output_stream_printf (surface->output,
		     "%d %d %d %d re f\n",
		     surface->surface_extents.x,
		     surface->surface_extents.y,
		     surface->surface_extents.width,
		     surface->surface_extents.height);

status = _cairo_pdf_surface_unselect_pattern (surface);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;
  }

  _cairo_composite_rectangles_fini (&extents);
  return _cairo_output_stream_get_status (surface->output);

8500cleanup:
  _cairo_composite_rectangles_fini (&extents);
  return status;
8503}

8505static cairo_int_status_t
8506_cairo_pdf_surface_mask (void			*abstract_surface,
	 cairo_operator_t	 op,
	 const cairo_pattern_t	*source,
	 const cairo_pattern_t	*mask,
	 const cairo_clip_t	*clip)
8511{
  cairo_pdf_surface_t *surface = abstract_surface;
  cairo_pdf_smask_group_t *group;
  cairo_composite_rectangles_t extents;
  cairo_int_status_t status;
  cairo_rectangle_int_t r;
  cairo_box_t box;
  double alpha;

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

  status = _cairo_pdf_interchange_add_operation_extents (surface, &extents.bounded);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) {
cairo_int_status_t source_status, mask_status;

status = _cairo_pdf_surface_analyze_operation (surface, op, source, &extents.bounded);
if (_cairo_int_status_is_error (status)((status) != CAIRO_INT_STATUS_SUCCESS && (status) <
 CAIRO_INT_STATUS_LAST_STATUS))
   goto cleanup;
source_status = status;

if (mask->has_component_alpha) {
   status = CAIRO_INT_STATUS_UNSUPPORTED;
} else {
   status = _cairo_pdf_surface_analyze_operation (surface, op, mask, &extents.bounded);
   if (_cairo_int_status_is_error (status)((status) != CAIRO_INT_STATUS_SUCCESS && (status) <
 CAIRO_INT_STATUS_LAST_STATUS))
goto cleanup;
}
mask_status = status;

_cairo_composite_rectangles_fini (&extents);
return _cairo_analysis_surface_merge_status (source_status,
				     mask_status);
  } else if (surface->paginated_mode == CAIRO_PAGINATED_MODE_FALLBACK) {
status = _cairo_pdf_surface_start_fallback (surface);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;
  }

  assert (_cairo_pdf_surface_operation_supported (surface, op, source, &extents.bounded))((void) sizeof (__assert_single_arg (_cairo_pdf_surface_operation_supported
 (surface, op, source, &extents.bounded))), __extension__
 ({ if (_cairo_pdf_surface_operation_supported (surface, op, source
, &extents.bounded)) ; else __assert_fail ("_cairo_pdf_surface_operation_supported (surface, op, source, &extents.bounded)"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 8556, __extension__ __PRETTY_FUNCTION__); }));
  assert (_cairo_pdf_surface_operation_supported (surface, op, mask, &extents.bounded))((void) sizeof (__assert_single_arg (_cairo_pdf_surface_operation_supported
 (surface, op, mask, &extents.bounded))), __extension__ (
{ if (_cairo_pdf_surface_operation_supported (surface, op, mask
, &extents.bounded)) ; else __assert_fail ("_cairo_pdf_surface_operation_supported (surface, op, mask, &extents.bounded)"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 8557, __extension__ __PRETTY_FUNCTION__); }));

  /* get the accurate extents */
  status = _cairo_pattern_get_ink_extents (source, &r);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  /* XXX slight impedance mismatch */
  _cairo_box_from_rectangle (&box, &r);
  status = _cairo_composite_rectangles_intersect_source_extents (&extents,
						   &box);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  status = _cairo_pattern_get_ink_extents (mask, &r);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  _cairo_box_from_rectangle (&box, &r);
  status = _cairo_composite_rectangles_intersect_mask_extents (&extents,
						 &box);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  status = _cairo_pdf_surface_set_clip (surface, &extents);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  status = _cairo_pdf_surface_select_operator (surface, op);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  /* Check if we can combine source and mask into a smask image */
  status = _cairo_pdf_surface_emit_combined_smask (surface, op, source, mask, &extents.bounded);
  if (status != CAIRO_INT_STATUS_UNSUPPORTED)
goto cleanup;

  /* Check if we can use a stencil mask */
  status = _cairo_pdf_surface_emit_stencil_mask (surface, op, source, mask, &extents.bounded);
  if (status != CAIRO_INT_STATUS_UNSUPPORTED)
goto cleanup;

  /* Check if we can set ca/CA instead of an smask. We could handle
   * other source patterns as well but for now this is the easiest,
   * and most common, case to handle. */
  if (_cairo_pattern_is_constant_alpha (mask, &extents.bounded, &alpha) &&
_can_paint_pattern (source)) {

status = _cairo_pdf_operators_flush (&surface->pdf_operators);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

_cairo_output_stream_printf (surface->output, "q\n");
status = _cairo_pdf_surface_paint_pattern (surface,
				   op,
				   source,
				   CAIRO_ANALYSIS_SOURCE_MASK,
				   &extents.bounded,
				   alpha,
				   FALSE0); /* mask */
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

_cairo_output_stream_printf (surface->output, "Q\n");
_cairo_composite_rectangles_fini (&extents);
return _cairo_output_stream_get_status (surface->output);
  }

  group = _cairo_pdf_surface_create_smask_group (surface, &extents.bounded);
  if (unlikely (group == NULL)(__builtin_expect (!!(group == ((void*)0)), 0))) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto cleanup;
  }

  group->operation = PDF_MASK;
  status = _cairo_pattern_create_copy (&group->source, source);
  if (unlikely (status)(__builtin_expect (!!(status), 0))) {
_cairo_pdf_smask_group_destroy (group);
goto cleanup;
  }
  status = _cairo_pattern_create_copy (&group->mask, mask);
  if (unlikely (status)(__builtin_expect (!!(status), 0))) {
_cairo_pdf_smask_group_destroy (group);
goto cleanup;
  }
  group->source_res = _cairo_pdf_surface_new_object (surface);
  if (group->source_res.id == 0) {
_cairo_pdf_smask_group_destroy (group);
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto cleanup;
  }

  status = _cairo_pdf_surface_add_smask_group (surface, group);
  if (unlikely (status)(__builtin_expect (!!(status), 0))) {
_cairo_pdf_smask_group_destroy (group);
goto cleanup;
  }

  status = _cairo_pdf_surface_add_smask (surface, group->group_res);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  status = _cairo_pdf_surface_add_xobject (surface, group->source_res);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  status = _cairo_pdf_operators_flush (&surface->pdf_operators);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  _cairo_output_stream_printf (surface->output,
		 "q /s%d gs /x%d Do Q\n",
		 group->group_res.id,
		 group->source_res.id);

  _cairo_composite_rectangles_fini (&extents);
  return _cairo_output_stream_get_status (surface->output);

8675cleanup:
  _cairo_composite_rectangles_fini (&extents);
  return status;
8678}

8680static cairo_int_status_t
8681_cairo_pdf_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)
8691{
  cairo_pdf_surface_t *surface = abstract_surface;
  cairo_pdf_smask_group_t *group;
  cairo_pdf_resource_t pattern_res, gstate_res;
  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)(__builtin_expect (!!(status), 0)))
return status;

  /* use the more accurate extents */
  if (extents.is_bounded) {
cairo_rectangle_int_t mask;
cairo_box_t box;

status = _cairo_path_fixed_stroke_extents (path, style,
				   ctm, ctm_inverse,
				   tolerance,
				   &mask);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

_cairo_box_from_rectangle (&box, &mask);
status = _cairo_composite_rectangles_intersect_mask_extents (&extents,
						     &box);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;
  }

  status = _cairo_pdf_interchange_add_operation_extents (surface, &extents.bounded);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

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

  assert (_cairo_pdf_surface_operation_supported (surface, op, source, &extents.bounded))((void) sizeof (__assert_single_arg (_cairo_pdf_surface_operation_supported
 (surface, op, source, &extents.bounded))), __extension__
 ({ if (_cairo_pdf_surface_operation_supported (surface, op, source
, &extents.bounded)) ; else __assert_fail ("_cairo_pdf_surface_operation_supported (surface, op, source, &extents.bounded)"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 8734, __extension__ __PRETTY_FUNCTION__); }));

  status = _cairo_pdf_surface_set_clip (surface, &extents);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  pattern_res.id = 0;
  gstate_res.id = 0;
  status = _cairo_pdf_surface_add_pdf_pattern (surface, source, op,
				 CAIRO_ANALYSIS_SOURCE_STROKE,
				 &extents.bounded,
				 &pattern_res, &gstate_res);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  status = _cairo_pdf_surface_select_operator (surface, op);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  if (gstate_res.id != 0) {
group = _cairo_pdf_surface_create_smask_group (surface, &extents.bounded);
if (unlikely (group == NULL)(__builtin_expect (!!(group == ((void*)0)), 0))) {
   status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
   goto cleanup;
}

group->operation = PDF_STROKE;
status = _cairo_pattern_create_copy (&group->source, source);
if (unlikely (status)(__builtin_expect (!!(status), 0))) {
   _cairo_pdf_smask_group_destroy (group);
   goto cleanup;
}
group->source_res = pattern_res;
status = _cairo_path_fixed_init_copy (&group->path, path);
if (unlikely (status)(__builtin_expect (!!(status), 0))) {
   _cairo_pdf_smask_group_destroy (group);
   goto cleanup;
}

group->style = *style;
group->ctm = *ctm;
group->ctm_inverse = *ctm_inverse;
status = _cairo_pdf_surface_add_smask_group (surface, group);
if (unlikely (status)(__builtin_expect (!!(status), 0))) {
   _cairo_pdf_smask_group_destroy (group);
   goto cleanup;
}

status = _cairo_pdf_surface_add_smask (surface, gstate_res);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

status = _cairo_pdf_surface_add_xobject (surface, group->group_res);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

status = _cairo_pdf_operators_flush (&surface->pdf_operators);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

_cairo_output_stream_printf (surface->output,
		     "q /s%d gs /x%d Do Q\n",
		     gstate_res.id,
		     group->group_res.id);
  } else {
status = _cairo_pdf_surface_select_pattern (surface, source, pattern_res, TRUE1);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

status = _cairo_pdf_operators_stroke (&surface->pdf_operators,
			      path,
			      style,
			      ctm,
			      ctm_inverse);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

status = _cairo_pdf_surface_unselect_pattern (surface);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;
  }

  _cairo_composite_rectangles_fini (&extents);
  return _cairo_output_stream_get_status (surface->output);

8819cleanup:
  _cairo_composite_rectangles_fini (&extents);
  return status;
8822}

8824static cairo_int_status_t
8825_cairo_pdf_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)
8833{
  cairo_pdf_surface_t *surface = abstract_surface;
  cairo_int_status_t status;
  cairo_pdf_smask_group_t *group;
  cairo_pdf_resource_t pattern_res, gstate_res;
  cairo_composite_rectangles_t extents;

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

  /* use the more accurate extents */
  if (extents.is_bounded) {
cairo_rectangle_int_t mask;
cairo_box_t box;

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

_cairo_box_from_rectangle (&box, &mask);
status = _cairo_composite_rectangles_intersect_mask_extents (&extents,
						     &box);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;
  }

  status = _cairo_pdf_interchange_add_operation_extents (surface, &extents.bounded);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) {
status = _cairo_pdf_surface_analyze_operation (surface, op, source, &extents.bounded);
goto cleanup;
  } else if (surface->paginated_mode == CAIRO_PAGINATED_MODE_FALLBACK) {
status = _cairo_pdf_surface_start_fallback (surface);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;
  }

  assert (_cairo_pdf_surface_operation_supported (surface, op, source, &extents.bounded))((void) sizeof (__assert_single_arg (_cairo_pdf_surface_operation_supported
 (surface, op, source, &extents.bounded))), __extension__
 ({ if (_cairo_pdf_surface_operation_supported (surface, op, source
, &extents.bounded)) ; else __assert_fail ("_cairo_pdf_surface_operation_supported (surface, op, source, &extents.bounded)"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 8877, __extension__ __PRETTY_FUNCTION__); }));

  status = _cairo_pdf_surface_set_clip (surface, &extents);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  status = _cairo_pdf_surface_select_operator (surface, op);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  if (_can_paint_pattern (source)) {
status = _cairo_pdf_operators_flush (&surface->pdf_operators);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

_cairo_output_stream_printf (surface->output, "q\n");
status =  _cairo_pdf_operators_clip (&surface->pdf_operators,
			     path,
			     fill_rule);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

status = _cairo_pdf_surface_paint_pattern (surface,
				   op,
				   source,
				   CAIRO_ANALYSIS_SOURCE_FILL,
				   &extents.bounded,
				   1.0, /* alpha */
				   FALSE0); /* mask */
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

_cairo_output_stream_printf (surface->output, "Q\n");
status = _cairo_output_stream_get_status (surface->output);
goto cleanup;
  }

  pattern_res.id = 0;
  gstate_res.id = 0;
  status = _cairo_pdf_surface_add_pdf_pattern (surface, source, op,
				 CAIRO_ANALYSIS_SOURCE_FILL,
				 &extents.bounded,
				 &pattern_res, &gstate_res);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  if (gstate_res.id != 0) {
group = _cairo_pdf_surface_create_smask_group (surface, &extents.bounded);
if (unlikely (group == NULL)(__builtin_expect (!!(group == ((void*)0)), 0))) {
   status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
   goto cleanup;
}

group->operation = PDF_FILL;
status = _cairo_pattern_create_copy (&group->source, source);
if (unlikely (status)(__builtin_expect (!!(status), 0))) {
   _cairo_pdf_smask_group_destroy (group);
   goto cleanup;
}
group->source_res = pattern_res;
status = _cairo_path_fixed_init_copy (&group->path, path);
if (unlikely (status)(__builtin_expect (!!(status), 0))) {
   _cairo_pdf_smask_group_destroy (group);
   goto cleanup;
}

group->fill_rule = fill_rule;
status = _cairo_pdf_surface_add_smask_group (surface, group);
if (unlikely (status)(__builtin_expect (!!(status), 0))) {
   _cairo_pdf_smask_group_destroy (group);
   goto cleanup;
}

status = _cairo_pdf_surface_add_smask (surface, gstate_res);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

status = _cairo_pdf_surface_add_xobject (surface, group->group_res);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

status = _cairo_pdf_operators_flush (&surface->pdf_operators);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

_cairo_output_stream_printf (surface->output,
		     "q /s%d gs /x%d Do Q\n",
		     gstate_res.id,
		     group->group_res.id);
  } else {
status = _cairo_pdf_surface_select_pattern (surface, source, pattern_res, FALSE0);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

status = _cairo_pdf_operators_fill (&surface->pdf_operators,
			    path,
			    fill_rule);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

status = _cairo_pdf_surface_unselect_pattern (surface);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;
  }

  _cairo_composite_rectangles_fini (&extents);
  return _cairo_output_stream_get_status (surface->output);

8985cleanup:
  _cairo_composite_rectangles_fini (&extents);
  return status;
8988}

8990static cairo_int_status_t
8991_cairo_pdf_surface_fill_stroke (void			*abstract_surface,
		cairo_operator_t	 fill_op,
		const cairo_pattern_t	*fill_source,
		cairo_fill_rule_t	 fill_rule,
		double			 fill_tolerance,
		cairo_antialias_t	 fill_antialias,
		const cairo_path_fixed_t*path,
		cairo_operator_t	 stroke_op,
		const cairo_pattern_t	*stroke_source,
		const cairo_stroke_style_t *stroke_style,
		const cairo_matrix_t	*stroke_ctm,
		const cairo_matrix_t	*stroke_ctm_inverse,
		double			 stroke_tolerance,
		cairo_antialias_t	 stroke_antialias,
		const cairo_clip_t	*clip)
9006{
  cairo_pdf_surface_t *surface = abstract_surface;
  cairo_int_status_t status;
  cairo_pdf_resource_t fill_pattern_res, stroke_pattern_res, gstate_res;
  cairo_composite_rectangles_t extents;

  /* During analysis we return unsupported and let the _fill and
   * _stroke functions that are on the fallback path do the analysis
   * for us. During render we may still encounter unsupported
   * combinations of fill/stroke patterns. However we can return
   * unsupported anytime to let the _fill and _stroke functions take
   * over.
   */
  if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE)
return CAIRO_INT_STATUS_UNSUPPORTED;

  /* PDF rendering of fill-stroke is not the same as cairo when
   * either the fill or stroke is not opaque.
   */
  if ( !_cairo_pattern_is_opaque (fill_source, NULL((void*)0)) ||
!_cairo_pattern_is_opaque (stroke_source, NULL((void*)0)))
  {
return CAIRO_INT_STATUS_UNSUPPORTED;
  }

  if (fill_op != stroke_op)
return CAIRO_INT_STATUS_UNSUPPORTED;

  /* Compute the operation extents using the stroke which will naturally
   * be larger than the fill extents.
   */
  status = _cairo_composite_rectangles_init_for_stroke (&extents,
					  &surface->base,
					  stroke_op, stroke_source,
					  path, stroke_style, stroke_ctm,
					  clip);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  /* use the more accurate extents */
  if (extents.is_bounded) {
cairo_rectangle_int_t mask;
cairo_box_t box;

status = _cairo_path_fixed_stroke_extents (path, stroke_style,
				   stroke_ctm, stroke_ctm_inverse,
				   stroke_tolerance,
				   &mask);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

_cairo_box_from_rectangle (&box, &mask);
status = _cairo_composite_rectangles_intersect_mask_extents (&extents,
						     &box);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;
  }

  status = _cairo_pdf_surface_set_clip (surface, &extents);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  status = _cairo_pdf_surface_select_operator (surface, fill_op);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  /* use the more accurate extents */
  if (extents.is_bounded) {
cairo_rectangle_int_t mask;
cairo_box_t box;

_cairo_path_fixed_fill_extents (path,
			fill_rule,
			fill_tolerance,
			&mask);

_cairo_box_from_rectangle (&box, &mask);
status = _cairo_composite_rectangles_intersect_mask_extents (&extents,
						     &box);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;
  }

  status = _cairo_pdf_interchange_add_operation_extents (surface, &extents.bounded);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  fill_pattern_res.id = 0;
  gstate_res.id = 0;
  status = _cairo_pdf_surface_add_pdf_pattern (surface, fill_source,
				 fill_op,
				 CAIRO_ANALYSIS_SOURCE_FILL,
				 &extents.bounded,
				 &fill_pattern_res,
				 &gstate_res);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  assert (gstate_res.id == 0)((void) sizeof (__assert_single_arg (gstate_res.id == 0)), __extension__
 ({ if (gstate_res.id == 0) ; else __assert_fail ("gstate_res.id == 0"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 9104, __extension__ __PRETTY_FUNCTION__); }));

  stroke_pattern_res.id = 0;
  gstate_res.id = 0;
  status = _cairo_pdf_surface_add_pdf_pattern (surface,
				 stroke_source,
				 stroke_op,
				 CAIRO_ANALYSIS_SOURCE_STROKE,
				 &extents.bounded,
				 &stroke_pattern_res,
				 &gstate_res);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  assert (gstate_res.id == 0)((void) sizeof (__assert_single_arg (gstate_res.id == 0)), __extension__
 ({ if (gstate_res.id == 0) ; else __assert_fail ("gstate_res.id == 0"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 9118, __extension__ __PRETTY_FUNCTION__); }));

  /* As PDF has separate graphics state for fill and stroke we can
   * select both at the same time */
  status = _cairo_pdf_surface_select_pattern (surface, fill_source,
				fill_pattern_res, FALSE0);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  status = _cairo_pdf_surface_select_pattern (surface, stroke_source,
				stroke_pattern_res, TRUE1);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  status = _cairo_pdf_operators_fill_stroke (&surface->pdf_operators,
			       path,
			       fill_rule,
			       stroke_style,
			       stroke_ctm,
			       stroke_ctm_inverse);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  status = _cairo_pdf_surface_unselect_pattern (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  _cairo_composite_rectangles_fini (&extents);
  return _cairo_output_stream_get_status (surface->output);

9148cleanup:
  _cairo_composite_rectangles_fini (&extents);
  return status;
9151}

9153static cairo_bool_t
9154_cairo_pdf_surface_has_show_text_glyphs	(void			*abstract_surface)
9155{
  return TRUE1;
9157}

9159static cairo_int_status_t
9160_cairo_pdf_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)
9172{
  cairo_pdf_surface_t *surface = abstract_surface;
  cairo_pdf_smask_group_t *group;
  cairo_pdf_resource_t pattern_res, gstate_res;
  cairo_composite_rectangles_t extents;
  cairo_bool_t overlap;
  cairo_int_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)(__builtin_expect (!!(status), 0)))
return status;

  status = _cairo_pdf_interchange_add_content (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  status = _cairo_pdf_interchange_add_operation_extents (surface, &extents.bounded);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) {
/* Enabling text in Type 3 fonts currently crashes cairo. Most
* PDF viewers don't seem to suport text in Type 3 so we let
* this go to image fallback.
*/
if (surface->type3_replay)
   return CAIRO_INT_STATUS_UNSUPPORTED;

status = _cairo_pdf_surface_analyze_operation (surface, op, source, &extents.bounded);
goto cleanup;
  }

  assert (_cairo_pdf_surface_operation_supported (surface, op, source, &extents.bounded))((void) sizeof (__assert_single_arg (_cairo_pdf_surface_operation_supported
 (surface, op, source, &extents.bounded))), __extension__
 ({ if (_cairo_pdf_surface_operation_supported (surface, op, source
, &extents.bounded)) ; else __assert_fail ("_cairo_pdf_surface_operation_supported (surface, op, source, &extents.bounded)"
, "/root/firefox-clang/gfx/cairo/cairo/src/cairo-pdf-surface.c"
, 9210, __extension__ __PRETTY_FUNCTION__); }));

  status = _cairo_pdf_surface_set_clip (surface, &extents);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  pattern_res.id = 0;
  gstate_res.id = 0;
  status = _cairo_pdf_surface_add_pdf_pattern (surface, source, op,
				 CAIRO_ANALYSIS_SOURCE_SHOW_GLYPHS,
				 &extents.bounded,
				 &pattern_res, &gstate_res);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  status = _cairo_pdf_surface_select_operator (surface, op);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;

  if (gstate_res.id != 0) {
group = _cairo_pdf_surface_create_smask_group (surface, &extents.bounded);
if (unlikely (group == NULL)(__builtin_expect (!!(group == ((void*)0)), 0))) {
   status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
   goto cleanup;
}

group->operation = PDF_SHOW_GLYPHS;
status = _cairo_pattern_create_copy (&group->source, source);
if (unlikely (status)(__builtin_expect (!!(status), 0))) {
   _cairo_pdf_smask_group_destroy (group);
   goto cleanup;
}
group->source_res = pattern_res;

if (utf8_len) {
   group->utf8 = _cairo_malloc (utf8_len)((utf8_len) != 0 ? malloc(utf8_len) : ((void*)0));
   if (unlikely (group->utf8 == NULL)(__builtin_expect (!!(group->utf8 == ((void*)0)), 0))) {
_cairo_pdf_smask_group_destroy (group);
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto cleanup;
   }
   memcpy (group->utf8, utf8, utf8_len);
}
group->utf8_len = utf8_len;

if (num_glyphs) {
   group->glyphs = _cairo_malloc_ab (num_glyphs, sizeof (cairo_glyph_t));
   if (unlikely (group->glyphs == NULL)(__builtin_expect (!!(group->glyphs == ((void*)0)), 0))) {
_cairo_pdf_smask_group_destroy (group);
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto cleanup;
   }
   memcpy (group->glyphs, glyphs, sizeof (cairo_glyph_t) * num_glyphs);
}
group->num_glyphs = num_glyphs;

if (num_clusters) {
   group->clusters = _cairo_malloc_ab (num_clusters, sizeof (cairo_text_cluster_t));
   if (unlikely (group->clusters == NULL)(__builtin_expect (!!(group->clusters == ((void*)0)), 0))) {
_cairo_pdf_smask_group_destroy (group);
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto cleanup;
   }
   memcpy (group->clusters, clusters, sizeof (cairo_text_cluster_t) * num_clusters);
}
group->num_clusters = num_clusters;

group->scaled_font = cairo_scaled_font_reference_moz_cairo_scaled_font_reference (scaled_font);
status = _cairo_pdf_surface_add_smask_group (surface, group);
if (unlikely (status)(__builtin_expect (!!(status), 0))) {
   _cairo_pdf_smask_group_destroy (group);
   goto cleanup;
}

status = _cairo_pdf_surface_add_smask (surface, gstate_res);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

status = _cairo_pdf_surface_add_xobject (surface, group->group_res);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

status = _cairo_pdf_operators_flush (&surface->pdf_operators);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

_cairo_output_stream_printf (surface->output,
		     "q /s%d gs /x%d Do Q\n",
		     gstate_res.id,
		     group->group_res.id);
  } else {
status = _cairo_pdf_surface_select_pattern (surface, source, pattern_res, FALSE0);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

/* User-fonts can use strokes; reset the stroke pattern as well. */
if (_cairo_font_face_is_user(scaled_font->font_face)) {
   status = _cairo_pdf_surface_select_pattern (surface, source, pattern_res, TRUE1);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;
}

/* Each call to show_glyphs() with a transclucent pattern must
* be in a separate text object otherwise overlapping text
* from separate calls to show_glyphs will not composite with
* each other. */
if (! _cairo_pattern_is_opaque (source, &extents.bounded)) {
   status = _cairo_pdf_operators_flush (&surface->pdf_operators);
   if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto cleanup;
}

status = _cairo_pdf_operators_show_text_glyphs (&surface->pdf_operators,
					utf8, utf8_len,
					glyphs, num_glyphs,
					clusters, num_clusters,
					cluster_flags,
					scaled_font);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;

status = _cairo_pdf_surface_unselect_pattern (surface);
if (unlikely (status)(__builtin_expect (!!(status), 0)))
   goto cleanup;
  }

  _cairo_composite_rectangles_fini (&extents);
  return _cairo_output_stream_get_status (surface->output);

9339cleanup:
  _cairo_composite_rectangles_fini (&extents);
  return status;
9342}

9344static const char **
9345_cairo_pdf_surface_get_supported_mime_types (void		 *abstract_surface)
9346{
  return _cairo_pdf_supported_mime_types;
9348}

9350static cairo_int_status_t
9351_cairo_pdf_surface_tag (void			   *abstract_surface,
	cairo_bool_t                begin,
	const char                 *tag_name,
	const char                 *attributes)

9356{
  cairo_pdf_surface_t *surface = abstract_surface;
  cairo_int_status_t status = CAIRO_INT_STATUS_SUCCESS;

  if (begin)
status = _cairo_pdf_interchange_tag_begin (surface, tag_name, attributes);
  else
status = _cairo_pdf_interchange_tag_end (surface, tag_name);

  return status;
9366}

9368static cairo_int_status_t
9369_cairo_pdf_surface_command_id (void                 *abstract_surface,
	       unsigned int          recording_id,
	       unsigned int          command_id)
9372{
  cairo_pdf_surface_t *surface = abstract_surface;

  return _cairo_pdf_interchange_command_id (surface, recording_id, command_id);
9376}

9378/* The Type 3 font subset support will the embed the
* CAIRO_SCALED_GLYPH_INFO_COLOR_SURFACE image if vector operations
* are not supported. The only case we don't currently handle is if a
* foreground color is used.
*/
9383static cairo_bool_t
9384_cairo_pdf_surface_supports_color_glyph (void                  *abstract_surface,
			 cairo_scaled_font_t   *scaled_font,
			 unsigned long          glyph_index)
9387{
  cairo_pdf_surface_t *surface = abstract_surface;
  cairo_pdf_color_glyph_t glyph_key;
  cairo_pdf_color_glyph_t *glyph_entry;
  cairo_scaled_glyph_t *scaled_glyph;
  cairo_status_t status;

  glyph_key.scaled_font = scaled_font;
  glyph_key.glyph_index = glyph_index;

  _cairo_pdf_color_glyph_init_key (&glyph_key);
  glyph_entry = _cairo_hash_table_lookup (surface->color_glyphs, &glyph_key.base);
  if (glyph_entry)
return glyph_entry->supported;

  glyph_entry = _cairo_calloc (sizeof (cairo_pdf_color_glyph_t))((sizeof (cairo_pdf_color_glyph_t)) != 0 ? calloc(1,sizeof (cairo_pdf_color_glyph_t
)) : ((void*)0));
  if (glyph_entry == NULL((void*)0)) {
status = _cairo_surface_set_error (&surface->base,
			   _cairo_error (CAIRO_STATUS_NO_MEMORY));
      return FALSE0;
  }

  glyph_entry->scaled_font = cairo_scaled_font_reference_moz_cairo_scaled_font_reference (scaled_font);
  glyph_entry->glyph_index = glyph_index;
  _cairo_pdf_color_glyph_init_key (glyph_entry);

  glyph_entry->supported = FALSE0;
  _cairo_scaled_font_freeze_cache (scaled_font);
  status = _cairo_scaled_glyph_lookup (scaled_font,
			 glyph_index,
			 CAIRO_SCALED_GLYPH_INFO_COLOR_SURFACE,
			 NULL((void*)0), /* foreground color */
			 &scaled_glyph);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
goto done;

  glyph_entry->supported = !(scaled_glyph->recording_uses_foreground_color ||
	       scaled_glyph->recording_uses_foreground_marker);

done:
  _cairo_scaled_font_thaw_cache (scaled_font);

  status = _cairo_hash_table_insert (surface->color_glyphs,
		       &glyph_entry->base);
  if (unlikely(status)(__builtin_expect (!!(status), 0))) {
status = _cairo_surface_set_error (&surface->base,
			   _cairo_error (CAIRO_STATUS_NO_MEMORY));
      return FALSE0;
  }

  return glyph_entry->supported;
9438}

9440static cairo_int_status_t
9441_cairo_pdf_surface_analyze_recording_surface(void		           *abstract_surface,
			     const cairo_surface_pattern_t *recording_surface_pattern,
			     unsigned int                   region_id,
			     cairo_analysis_source_t        source_type,
			     cairo_bool_t                   begin)
9446{
  cairo_pdf_surface_t *surface = abstract_surface;
  cairo_int_status_t status = CAIRO_INT_STATUS_SUCCESS;

  if (begin) {
status = _cairo_pdf_interchange_recording_source_surface_begin (
   surface,
   recording_surface_pattern,
   region_id,
   source_type);
  } else {
status = _cairo_pdf_interchange_recording_source_surface_end (
   surface,
   recording_surface_pattern,
   region_id,
   source_type);
  }

  return status;
9465}

9467static cairo_int_status_t
9468_cairo_pdf_surface_set_paginated_mode (void			*abstract_surface,
		       cairo_paginated_mode_t	 paginated_mode)
9470{
  cairo_pdf_surface_t *surface = abstract_surface;
  cairo_int_status_t status;

  surface->paginated_mode = paginated_mode;

  status = _cairo_pdf_interchange_begin_page_content (surface);
  if (unlikely (status)(__builtin_expect (!!(status), 0)))
return status;

  if (paginated_mode == CAIRO_PAGINATED_MODE_RENDER) {
surface->surface_extents.x = 0;
surface->surface_extents.y = 0;
surface->surface_extents.width  = ceil (surface->width);
surface->surface_extents.height = ceil (surface->height);
  }

  return CAIRO_INT_STATUS_SUCCESS;
9488}

9490static const cairo_surface_backend_t cairo_pdf_surface_backend = {
  CAIRO_SURFACE_TYPE_PDF,
  _cairo_pdf_surface_finish,

  _cairo_default_context_create,

  NULL((void*)0), /* create similar: handled by wrapper */
  NULL((void*)0), /* create similar image */
  NULL((void*)0), /* map to image */
  NULL((void*)0), /* unmap image */

  _cairo_surface_default_source,
  NULL((void*)0), /* acquire_source_image */
  NULL((void*)0), /* release_source_image */
  NULL((void*)0), /* snapshot */

  NULL((void*)0),  /* _cairo_pdf_surface_copy_page */
  _cairo_pdf_surface_show_page,

  _cairo_pdf_surface_get_extents,
  _cairo_pdf_surface_get_font_options,

  NULL((void*)0), /* flush */
  NULL((void*)0), /* mark_dirty_rectangle */

  /* Here are the drawing functions */
  _cairo_pdf_surface_paint,
  _cairo_pdf_surface_mask,
  _cairo_pdf_surface_stroke,
  _cairo_pdf_surface_fill,
  _cairo_pdf_surface_fill_stroke,
  NULL((void*)0), /* show_glyphs */
  _cairo_pdf_surface_has_show_text_glyphs,
  _cairo_pdf_surface_show_text_glyphs,
  _cairo_pdf_surface_get_supported_mime_types,
  _cairo_pdf_surface_tag,
  _cairo_pdf_surface_supports_color_glyph,
  _cairo_pdf_surface_analyze_recording_surface,
  _cairo_pdf_surface_command_id,
9529};

9531static const cairo_paginated_surface_backend_t
9532cairo_pdf_surface_paginated_backend = {
  _cairo_pdf_surface_start_page,
  _cairo_pdf_surface_set_paginated_mode,
  NULL((void*)0), /* set_bounding_box */
  _cairo_pdf_surface_has_fallback_images,
  _cairo_pdf_surface_supports_fine_grained_fallbacks,
  _cairo_pdf_surface_requires_thumbnail_image,
  _cairo_pdf_surface_set_thumbnail_image,
9540};