/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */

/* cairo - a vector graphics library with display and print output

 *

 * Copyright © 2000 Keith Packard

 * Copyright © 2005 Red Hat, Inc

 *

 * 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 Red Hat, Inc.

 *

 * Contributor(s):

 *      Graydon Hoare <graydon@redhat.com>

 *	Owen Taylor <otaylor@redhat.com>

 *      Keith Packard <keithp@keithp.com>

 *      Carl Worth <cworth@cworth.org>

 */

#define _DEFAULT_SOURCE /* for strdup() */

#include "cairoint.h"

#include "cairo-error-private.h"

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

#include "cairo-ft-private.h"

#include "cairo-list-inline.h"

#include "cairo-path-private.h"

#include "cairo-pattern-private.h"

#include "cairo-pixman-private.h"

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

#include <float.h>

#include "cairo-fontconfig-private.h"

#include <ft2build.h>

#include FT_FREETYPE_H

#include FT_OUTLINE_H

#include FT_IMAGE_H

#include FT_BITMAP_H

#include FT_TRUETYPE_TABLES_H

#include FT_FONT_FORMATS_H

#include FT_MULTIPLE_MASTERS_H

#include FT_SYNTHESIS_H

#include FT_LCD_FILTER_H

#if HAVE_FT_SVG_DOCUMENT

#include FT_OTSVG_H

#endif

#if HAVE_UNISTD_H

#include <unistd.h>

#elif !defined(access)

#define access(p, m) 0

#endif

/*  FreeType version older than 2.11 does not have the FT_RENDER_MODE_SDF enum value in FT_Render_Mode */

#if FREETYPE_MAJOR > 2 || (FREETYPE_MAJOR == 2 && FREETYPE_MINOR >= 11)

#define HAVE_FT_RENDER_MODE_SDF 1

#endif

#define DOUBLE_FROM_26_6(t) ((double)(t) / 64.0)

#define DOUBLE_TO_16_16(d) ((FT_Fixed)((d) * 65536.0))

#define DOUBLE_FROM_16_16(t) ((double)(t) / 65536.0)

/* SCALE() mimics code from commit 399b00a99b2bbc1c56a05974c936aa69a08021f5

 * concerning a potential division by 0, but instead of doing a * (1/b), it

 * does a/b, thus improving the accuracy. With a * (1/b), for a bitmap font

 * of size 13, the computed -y_bearing was 0x1.6000000000001p+3 instead of

 * 0x1.6p+3 (= 11). This triggered a bug in GNU Emacs (when built against

 * cairo), which rounded the value to an integer with ceil().

 * Details:

 *   https://gitlab.freedesktop.org/cairo/cairo/-/issues/503

 *   https://debbugs.gnu.org/cgi/bugreport.cgi?bug=44284

 *

 * Note that rounding errors are not necessarily expected by applications

 * in simple cases like the GNU Emacs one (an identity transformation,

 * which should normally leave the inputs unchanged). However, with the

 * current cairo code, due to the scaling, there is no guarantee that

 * rounding errors will always be avoided at the end. For instance,

 * (a/b)*b may be different from a, but this is still better than doing

 * (a*(1/b))*b.

 *

 * According to the commit mentioned above, avoiding a division by zero

 * was an attempt to fix

 *   https://bugzilla.gnome.org/show_bug.cgi?id=311299

 * but this did not actually solve the problem. So it might be possible

 * to change SCALE() to just do (a) / (b).

 */

#define SCALE(a,b) ((b) == 0 ? 0.0 : (a) / (b))

/* This is the max number of FT_face objects we keep open at once

 */

#define MAX_OPEN_FACES 10

/**

 * SECTION:cairo-ft

 * @Title: FreeType Fonts

 * @Short_Description: Font support for FreeType

 * @See_Also: #cairo_font_face_t

 *

 * The FreeType font backend is primarily used to render text on GNU/Linux

 * systems, but can be used on other platforms too.

 **/

/**

 * CAIRO_HAS_FT_FONT:

 *

 * Defined if the FreeType font backend is available.

 * This macro can be used to conditionally compile backend-specific code.

 *

 * Since: 1.0

 **/

/**

 * CAIRO_HAS_FC_FONT:

 *

 * Defined if the Fontconfig-specific functions of the FreeType font backend

 * are available.

 * This macro can be used to conditionally compile backend-specific code.

 *

 * Since: 1.10

 **/

/*

 * The simple 2x2 matrix is converted into separate scale and shape

 * factors so that hinting works right

 */

typedef struct _cairo_ft_font_transform {

    double  x_scale, y_scale;

    double  shape[2][2];

} cairo_ft_font_transform_t;

/*

 * We create an object that corresponds to a single font on the disk;

 * (identified by a filename/id pair) these are shared between all

 * fonts using that file.  For cairo_ft_font_face_create_for_ft_face(), we

 * just create a one-off version with a permanent face value.

 */

typedef struct _cairo_ft_font_face cairo_ft_font_face_t;

struct _cairo_ft_unscaled_font {

    cairo_unscaled_font_t base;

    cairo_bool_t from_face; /* was the FT_Face provided by user? */

    FT_Face face;	    /* provided or cached face */

    /* only set if from_face is false */

    char *filename;

    int id;

    /* We temporarily scale the unscaled font as needed */

    cairo_bool_t have_scale;

    cairo_matrix_t current_scale;

    double x_scale;		/* Extracted X scale factor */

    double y_scale;             /* Extracted Y scale factor */

    cairo_bool_t have_shape;	/* true if the current scale has a non-scale component*/

    cairo_matrix_t current_shape;

    FT_Matrix Current_Shape;

    unsigned int have_color_set  : 1;

    unsigned int have_color      : 1;  /* true if the font contains color glyphs */

    FT_Fixed *variations;              /* variation settings that FT_Face came */

    unsigned int num_palettes;

    cairo_mutex_t mutex;

    int lock_count;

    cairo_ft_font_face_t *faces;	/* Linked list of faces for this font */

};

static int

_cairo_ft_unscaled_font_keys_equal (const void *key_a,

				    const void *key_b);

static void

_cairo_ft_unscaled_font_fini (cairo_ft_unscaled_font_t *unscaled);

typedef struct _cairo_ft_options {

    cairo_font_options_t base;

    unsigned int load_flags; /* flags for FT_Load_Glyph */

    unsigned int synth_flags;

} cairo_ft_options_t;

static void

                             const cairo_ft_options_t *other)

{

static void

{

struct _cairo_ft_font_face {

    cairo_font_face_t base;

    cairo_ft_unscaled_font_t *unscaled;

    cairo_ft_options_t ft_options;

    cairo_ft_font_face_t *next;

#if CAIRO_HAS_FC_FONT

    FcPattern *pattern; /* if pattern is set, the above fields will be NULL */

    cairo_font_face_t *resolved_font_face;

    FcConfig *resolved_config;

#endif

};

static const cairo_unscaled_font_backend_t cairo_ft_unscaled_font_backend;

#if CAIRO_HAS_FC_FONT

static cairo_status_t

_cairo_ft_font_options_substitute (const cairo_font_options_t *options,

				   FcPattern                  *pattern);

static cairo_font_face_t *

_cairo_ft_resolve_pattern (FcPattern		      *pattern,

			   const cairo_matrix_t       *font_matrix,

			   const cairo_matrix_t       *ctm,

			   const cairo_font_options_t *options);

#endif

cairo_status_t

{

  /* Currently we don't get many (any?) useful statuses here.

   * Populate as needed. */

  {

  }

}

/*

 * We maintain a hash table to map file/id => #cairo_ft_unscaled_font_t.

 * The hash table itself isn't limited in size. However, we limit the

 * number of FT_Face objects we keep around; when we've exceeded that

 * limit and need to create a new FT_Face, we dump the FT_Face from a

 * random #cairo_ft_unscaled_font_t which has an unlocked FT_Face, (if

 * there are any).

 */

typedef struct _cairo_ft_unscaled_font_map {

    cairo_hash_table_t *hash_table;

    FT_Library ft_library;

    int num_open_faces;

} cairo_ft_unscaled_font_map_t;

static cairo_ft_unscaled_font_map_t *cairo_ft_unscaled_font_map = NULL;

static FT_Face

_cairo_ft_unscaled_font_lock_face (cairo_ft_unscaled_font_t *unscaled);

static void

_cairo_ft_unscaled_font_unlock_face (cairo_ft_unscaled_font_t *unscaled);

static cairo_bool_t

_cairo_ft_scaled_font_is_vertical (cairo_scaled_font_t *scaled_font);

static void

				  cairo_ft_unscaled_font_t *unscaled)

{

    }

static cairo_status_t

{

    cairo_ft_unscaled_font_map_t *font_map;

    /* This function is only intended to be called from

     * _cairo_ft_unscaled_font_map_lock. So we'll crash if we can

     * detect some other call path. */

}

static void

{

			      &unscaled->base.hash_entry);

static void

{

    cairo_ft_unscaled_font_map_t *font_map;

				   _cairo_ft_unscaled_font_map_pluck_entry,

				   font_map);

    }

static cairo_ft_unscaled_font_map_t *

{

    CAIRO_MUTEX_INITIALIZE ();

	}

    }

}

static void

{

static void

				  cairo_bool_t              from_face,

				  char			   *filename,

				  int			    id,

				  FT_Face		    face)

{

    uintptr_t hash;

    /* the constants are just arbitrary primes */

/**

 * _cairo_ft_unscaled_font_init:

 *

 * Initialize a #cairo_ft_unscaled_font_t.

 *

 * There are two basic flavors of #cairo_ft_unscaled_font_t, one

 * created from an FT_Face and the other created from a filename/id

 * pair. These two flavors are identified as from_face and !from_face.

 *

 * To initialize a from_face font, pass filename==%NULL, id=0 and the

 * desired face.

 *

 * To initialize a !from_face font, pass the filename/id as desired

 * and face==%NULL.

 *

 * Note that the code handles these two flavors in very distinct

 * ways. For example there is a hash_table mapping

 * filename/id->#cairo_unscaled_font_t in the !from_face case, but no

 * parallel in the from_face case, (where the calling code would have

 * to do its own mapping to ensure similar sharing).

 **/

static cairo_status_t

			      cairo_bool_t              from_face,

			      const char	       *filename,

			      int			id,

			      FT_Face			face)

{

			       &cairo_ft_unscaled_font_backend);

	FT_MM_Var *ft_mm_var;

	}

    } else {

	char *filename_copy;

    }

}

/**

 * _cairo_ft_unscaled_font_fini:

 *

 * Free all data associated with a #cairo_ft_unscaled_font_t.

 *

 * CAUTION: The unscaled->face field must be %NULL before calling this

 * function. This is because the #cairo_ft_unscaled_font_t_map keeps a

 * count of these faces (font_map->num_open_faces) so it maintains the

 * unscaled->face field while it has its lock held. See

 * _font_map_release_face_lock_held().

 **/

static void

{

static int

				    const void *key_b)

{

     {

	else

    }

}

/* Finds or creates a #cairo_ft_unscaled_font_t for the filename/id from

 * pattern.  Returns a new reference to the unscaled font.

 */

static cairo_status_t

					 char *filename,

					 int id,

					 FT_Face font_face,

					 cairo_ft_unscaled_font_t **out)

{

    cairo_ft_unscaled_font_t key, *unscaled;

    cairo_ft_unscaled_font_map_t *font_map;

    cairo_status_t status;

    /* Return existing unscaled font if it exists in the hash table. */

					 &key.base.hash_entry);

    }

    /* Otherwise create it and insert into hash table. */

    }

				       &unscaled->base.hash_entry);

}

#if CAIRO_HAS_FC_FONT

static cairo_status_t

					    cairo_ft_unscaled_font_t **out)

{

    FcResult ret;

	    /* If FC_INDEX is not set, we just use 0 */

	} else

    }

    /* The pattern contains neither a face nor a filename, resolve it later. */

						    filename, id, font_face,

						    out);

}

#endif

static cairo_status_t

					  cairo_ft_unscaled_font_t **out)

{

}

static cairo_bool_t

{

    cairo_ft_unscaled_font_map_t *font_map;

    /* All created objects must have been mapped in the font map. */

	/* somebody recreated the font whilst we waited for the lock */

    }

			      &unscaled->base.hash_entry);

	/* See comments in _ft_font_face_destroy about the "zombie" state

	 * for a _ft_font_face.

	 */

	}

    } else {

    }

}

static cairo_bool_t

{

}

/* Ensures that an unscaled font has a face object. If we exceed

 * MAX_OPEN_FACES, try to close some.

 *

 * This differs from _cairo_ft_scaled_font_lock_face in that it doesn't

 * set the scale on the face, but just returns it at the last scale.

 */

static cairo_warn FT_Face

{

    cairo_ft_unscaled_font_map_t *font_map;

    FT_Error error;

    /* If this unscaled font was created from an FT_Face then we just

     * returned it above. */

    {

	{

	    cairo_ft_unscaled_font_t *entry;

						    _has_unlocked_face);

	}

    }

			 &face);

    {

    }

}

/* Unlock unscaled font locked with _cairo_ft_unscaled_font_lock_face

 */

static void

{

static cairo_status_t

		    cairo_matrix_t      *scale,

		    cairo_ft_unscaled_font_t *unscaled)

{

    cairo_status_t status;

    double x_scale, y_scale;

    /* The font matrix has x and y "scale" components which we extract and

     * use as character scale values. These influence the way freetype

     * chooses hints, as well as selecting different bitmaps in

     * hand-rendered fonts. We also copy the normalized matrix to

     * freetype's transformation.

     */

						  &x_scale, &y_scale,

						  1);

    /* FreeType docs say this about x_scale and y_scale:

     * "A character width or height smaller than 1pt is set to 1pt;"

     * So, we cap them from below at 1.0 and let the FT transform

     * take care of sub-1.0 scaling. */

	int i;

	    /*

	     * distance is positive if current strike is larger than desired

	     * size, and negative if smaller.

	     *

	     * We like to prefer down-scaling to upscaling.

	     */

	    }

	}

    }

			      &sf->shape[0][0], &sf->shape[0][1],

			      &sf->shape[1][0], &sf->shape[1][1],

			      NULL, NULL);

}

/* Temporarily scales an unscaled font to the give scale. We catch

 * scaling to the same size, since changing a FT_Face is expensive.

 */

static cairo_status_t

				   cairo_matrix_t	      *scale)

{

    cairo_status_t status;

    cairo_ft_font_transform_t sf;

    FT_Matrix mat;

    FT_Error error;

		       sf.shape[0][0], sf.shape[0][1],

		       sf.shape[1][0], sf.shape[1][1],

		       0.0, 0.0);

			      0, 0);

}

/* we sometimes need to convert the glyph bitmap in a FT_GlyphSlot

 * into a different format. For example, we want to convert a

 * FT_PIXEL_MODE_LCD or FT_PIXEL_MODE_LCD_V bitmap into a 32-bit

 * ARGB or ABGR bitmap.

 *

 * this function prepares a target descriptor for this operation.

 *

 * input :: target bitmap descriptor. The function will set its

 *          'width', 'rows' and 'pitch' fields, and only these

 *

 * slot  :: the glyph slot containing the source bitmap. this

 *          function assumes that slot->format == FT_GLYPH_FORMAT_BITMAP

 *

 * mode  :: the requested final rendering mode. supported values are

 *          MONO, NORMAL (i.e. gray), LCD and LCD_V

 *

 * the function returns the size in bytes of the corresponding buffer,

 * it's up to the caller to allocate the corresponding memory block

 * before calling _fill_xrender_bitmap

 *

 * it also returns -1 in case of error (e.g. incompatible arguments,

 * like trying to convert a gray bitmap into a monochrome one)

 */

static int

			     FT_GlyphSlot    slot,

			     FT_Render_Mode  mode)

{

    FT_Bitmap *ftbit;

    int width, height, pitch;

    /* compute the size of the final bitmap */

	}

	/* fall-through */

    case FT_PIXEL_MODE_GRAY:

	    mode == FT_RENDER_MODE_LCD_V)

	{

	    /* each pixel is replicated into a 32-bit ARGB value */

	}

	/* horz pixel triplets are packed into 32-bit ARGB values */

	/* vert pixel triplets are packed into 32-bit ARGB values */

	/* each pixel is replicated into a 32-bit ARGB value */

    }

}

/* this functions converts the glyph bitmap found in a FT_GlyphSlot

 * into a different format (see _compute_xrender_bitmap_size)

 *

 * you should call this function after _compute_xrender_bitmap_size

 *

 * target :: target bitmap descriptor. Note that its 'buffer' pointer

 *           must point to memory allocated by the caller

 *

 * slot   :: the glyph slot containing the source bitmap

 *

 * mode   :: the requested final rendering mode

 *

 * bgr    :: boolean, set if BGR or VBGR pixel ordering is needed

 */

static void

		     FT_GlyphSlot    slot,

		     FT_Render_Mode  mode,

		     int             bgr)

{

    int subpixel;

    int h;

		mode == FT_RENDER_MODE_LCD_V);

	    /* convert mono to ARGB32 values */

		int x;

		}

	    }

	    /* convert mono to 8-bit gray */

		int x;

		}

	    }

	} else {

	    /* copy mono to mono */

	}

	    /* convert gray to ARGB32 values */

		int x;

		}

	    }

        } else {

            /* copy gray into gray */

        }

	    /* convert horizontal RGB into ARGB32 */

		int x;

		    unsigned int  pix;

		}

	    }

	} else {

	    /* convert horizontal BGR into ARGB32 */

		int x;

		    unsigned int  pix;

		}

	    }

	}

	/* convert vertical RGB into ARGB32 */

		int x;

		    unsigned int pix;

		}

	    }

	} else {

		int x;

		    unsigned int  pix;

		}

	    }

	}

    }

/* Fills in val->image with an image surface created from @bitmap

 */

static cairo_status_t

		     FT_Library		      library,

		     cairo_bool_t	      own_buffer,

		     cairo_font_options_t    *font_options,

		     cairo_image_surface_t  **surface)

{

    unsigned int width, height;

    unsigned char *data;

    int stride;

    cairo_image_surface_t *image;

    }

	} else {

	    } else {

		int i;

		unsigned char *source, *dest;

		}

	    }

	}

#ifndef WORDS_BIGENDIAN

	{

	    }

	}

#endif

    case FT_PIXEL_MODE_LCD_V:

    case FT_PIXEL_MODE_GRAY:

	{

	    /* We don't support stride not multiple of 4. */

	    {

	    }

	    } else {

	    }

	} else {

	}

	} else {

	}

	{

	    /* Byteswap. */

	}

    case FT_PIXEL_MODE_GRAY2:

    case FT_PIXEL_MODE_GRAY4:

	{

	    /* This is pretty much the only case that we can get in here. */