/*

 * Copyright © 2026  Behdad Esfahbod

 *

 *  This is part of HarfBuzz, a text shaping library.

 *

 * Permission is hereby granted, without written agreement and without

 * license or royalty fees, to use, copy, modify, and distribute this

 * software and its documentation for any purpose, provided that the

 * above copyright notice and the following two paragraphs appear in

 * all copies of this software.

 *

 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR

 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES

 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN

 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH

 * DAMAGE.

 *

 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,

 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

 * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS

 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO

 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 *

 * Author(s): Behdad Esfahbod

 */

#include "hb.hh"

#include "hb-vector-paint.hh"

#include "hb-vector-draw.hh"

#include "hb-paint.hh"

#include <math.h>

#include <stdio.h>

#ifdef HAVE_ZLIB

#include <zlib.h>

#endif

/* PDF paint backend for COLRv0/v1 color font rendering.

 *

 * Supports:

 *   - Solid colors with alpha (via ExtGState)

 *   - Glyph and rectangle clipping

 *   - Affine transforms

 *   - Groups (save/restore)

 *   - Linear gradients (PDF Type 2 axial shading)

 *   - Radial gradients (PDF Type 3 radial shading)

 *   - Sweep gradients (approximated via solid fallback)

 */

/* ---- PDF object collector ---- */

struct hb_pdf_obj_t

{

  hb_vector_buf_t data;

};

/* Collects extra PDF objects (shadings, functions, ExtGState)

 * during painting.  Referenced from the content stream by name

 * (e.g. /SH0, /GS0) and emitted at render time. */

static bool

hb_pdf_build_indexed_smask (hb_vector_buf_t *out,

          const char *idat_data, unsigned idat_len,

          unsigned width, unsigned height,

          const uint8_t *trns, unsigned trns_len);

struct hb_pdf_resources_t

{

  hb_vector_t<hb_pdf_obj_t> objects;   /* extra objects, starting at id 5 */

  hb_vector_buf_t extgstate_dict;    /* /GS0 5 0 R /GS1 6 0 R ... */

  hb_vector_buf_t shading_dict;      /* /SH0 7 0 R ... */

  hb_vector_buf_t xobject_dict;      /* /Im0 8 0 R ... */

  unsigned extgstate_count = 0;

  unsigned shading_count = 0;

  unsigned xobject_count = 0;

  unsigned add_object (hb_vector_buf_t &&obj_data)

  {

    unsigned id = 5 + objects.length; /* objects 1-4 are fixed */

    hb_pdf_obj_t obj;

    obj.data = std::move (obj_data);

    objects.push (std::move (obj));

    return id;

  }

  /* Add ExtGState for fill opacity, return resource name index. */

  unsigned add_extgstate_alpha (float alpha)

  {

    unsigned idx = extgstate_count++;

    hb_vector_buf_t obj;

    obj.append_str ("<< /Type /ExtGState /ca ");

    obj.append_num (alpha, 4);

    obj.append_str (" >>");

    unsigned obj_id = add_object (std::move (obj));

    extgstate_dict.append_str ("/GS");

    extgstate_dict.append_unsigned (idx);

    extgstate_dict.append_c (' ');

    extgstate_dict.append_unsigned (obj_id);

    extgstate_dict.append_str (" 0 R ");

    return idx;

  }

  /* Add ExtGState for blend mode, return resource name index. */

  unsigned add_extgstate_blend (const char *bm)

  {

    unsigned idx = extgstate_count++;

    hb_vector_buf_t obj;

    obj.append_str ("<< /Type /ExtGState /BM /");

    obj.append_str (bm);

    obj.append_str (" >>");

    unsigned obj_id = add_object (std::move (obj));

    extgstate_dict.append_str ("/GS");

    extgstate_dict.append_unsigned (idx);

    extgstate_dict.append_c (' ');

    extgstate_dict.append_unsigned (obj_id);

    extgstate_dict.append_str (" 0 R ");

    return idx;

  }

  /* Add ExtGState with an SMask (soft mask) referencing a Form XObject

   * that paints a DeviceGray shading.  Returns the ExtGState resource index. */

  unsigned add_extgstate_smask (unsigned alpha_shading_id,

        float bbox_x, float bbox_y,

        float bbox_w, float bbox_h,

        unsigned precision)

  {

    /* Form XObject: transparency group painting the alpha shading. */

    hb_vector_buf_t form_stream;

    form_stream.append_str ("/SHa sh\n");

    hb_vector_buf_t form;

    form.append_str ("<< /Type /XObject /Subtype /Form\n");

    form.append_str ("/BBox [");

    form.append_num (bbox_x, precision);

    form.append_c (' ');

    form.append_num (bbox_y, precision);

    form.append_c (' ');

    form.append_num (bbox_x + bbox_w, precision);

    form.append_c (' ');

    form.append_num (bbox_y + bbox_h, precision);

    form.append_str ("]\n/Group << /S /Transparency /CS /DeviceGray >>\n");

    form.append_str ("/Resources << /Shading << /SHa ");

    form.append_unsigned (alpha_shading_id);

    form.append_str (" 0 R >> >>\n");

    form.append_str ("/Length ");

    form.append_unsigned (form_stream.length);

    form.append_str (" >>\nstream\n");

    form.append_len (form_stream.arrayZ, form_stream.length);

    form.append_str ("endstream");

    unsigned form_id = add_object (std::move (form));

    /* ExtGState with luminosity soft mask. */

    unsigned idx = extgstate_count++;

    hb_vector_buf_t gs;

    gs.append_str ("<< /Type /ExtGState\n");

    gs.append_str ("/SMask << /Type /Mask /S /Luminosity /G ");

    gs.append_unsigned (form_id);

    gs.append_str (" 0 R >> >>");

    unsigned gs_id = add_object (std::move (gs));

    extgstate_dict.append_str ("/GS");

    extgstate_dict.append_unsigned (idx);

    extgstate_dict.append_c (' ');

    extgstate_dict.append_unsigned (gs_id);

    extgstate_dict.append_str (" 0 R ");

    return idx;

  }

  /* Add a shading, return resource name index. */

  unsigned add_shading (hb_vector_buf_t &&shading_data)

  {

    unsigned obj_id = add_object (std::move (shading_data));

    return add_shading_by_id (obj_id);

  }

  /* Register an already-allocated object as a shading resource. */

  unsigned add_shading_by_id (unsigned obj_id)

  {

    unsigned idx = shading_count++;

    shading_dict.append_str ("/SH");

    shading_dict.append_unsigned (idx);

    shading_dict.append_c (' ');

    shading_dict.append_unsigned (obj_id);

    shading_dict.append_str (" 0 R ");

    return idx;

  }

  /* Add an XObject image, return resource name index.

   * idat_data/idat_len is the concatenated PNG IDAT payload (zlib data).

   * colors is 1 (gray), 3 (RGB), or 4 (RGBA); for indexed, pass colors=1.

   * plte/plte_len is the PLTE chunk data for indexed images (may be null). */

  unsigned add_xobject_png_image (const char *idat_data, unsigned idat_len,

          unsigned width, unsigned height,

          unsigned colors, bool has_alpha,

          const uint8_t *plte = nullptr,

          unsigned plte_len = 0,

          const uint8_t *trns = nullptr,

          unsigned trns_len = 0)

  {

    unsigned idx = xobject_count++;

    hb_vector_buf_t obj;

    obj.append_str ("<< /Type /XObject /Subtype /Image\n");

    obj.append_str ("/Width ");

    obj.append_unsigned (width);

    obj.append_str (" /Height ");

    obj.append_unsigned (height);

    obj.append_str ("\n/BitsPerComponent 8\n");

    if (plte && plte_len >= 3)

    {

      /* Indexed color: /ColorSpace [/Indexed /DeviceRGB N <hex palette>] */

      unsigned n_entries = plte_len / 3;

      obj.append_str ("/ColorSpace [/Indexed /DeviceRGB ");

      obj.append_unsigned (n_entries - 1);

      obj.append_str (" <");

      for (unsigned i = 0; i < n_entries * 3; i++)

      {

  obj.append_c ("0123456789ABCDEF"[plte[i] >> 4]);

  obj.append_c ("0123456789ABCDEF"[plte[i] & 0xF]);

      }

      obj.append_str (">]\n");

    }

    else

    {

      obj.append_str ("/ColorSpace ");

      unsigned color_channels = has_alpha ? colors - 1 : colors;

      obj.append_str (color_channels == 1 ? "/DeviceGray" : "/DeviceRGB");

      obj.append_c ('\n');

    }

    /* Build SMask for indexed images with tRNS transparency. */

    unsigned smask_id = 0;

    if (plte && trns && trns_len)

    {

      hb_vector_buf_t smask_stream;

      if (hb_pdf_build_indexed_smask (&smask_stream, idat_data, idat_len,

              width, height, trns, trns_len))

      {

  hb_vector_buf_t smask_obj;

  smask_obj.append_str ("<< /Type /XObject /Subtype /Image\n");

  smask_obj.append_str ("/Width ");

  smask_obj.append_unsigned (width);

  smask_obj.append_str (" /Height ");

  smask_obj.append_unsigned (height);

  smask_obj.append_str ("\n/ColorSpace /DeviceGray /BitsPerComponent 8\n");

  smask_obj.append_str ("/Length ");

  smask_obj.append_unsigned (smask_stream.length);

  smask_obj.append_str (" >>\nstream\n");

  smask_obj.append_len (smask_stream.arrayZ, smask_stream.length);

  smask_obj.append_str ("\nendstream");

  smask_id = add_object (std::move (smask_obj));

      }

    }

    if (smask_id)

    {

      obj.append_str ("/SMask ");

      obj.append_unsigned (smask_id);

      obj.append_str (" 0 R\n");

    }

    obj.append_str ("/Filter /FlateDecode\n");

    obj.append_str ("/DecodeParms << /Predictor 15 /Colors ");

    obj.append_unsigned (colors);

    obj.append_str (" /BitsPerComponent 8 /Columns ");

    obj.append_unsigned (width);

    obj.append_str (" >>\n");

    obj.append_str ("/Length ");

    obj.append_unsigned (idat_len);

    obj.append_str (" >>\nstream\n");

    obj.append_len (idat_data, idat_len);

    obj.append_str ("\nendstream");

    (void) has_alpha;

    unsigned obj_id = add_object (std::move (obj));

    xobject_dict.append_str ("/Im");

    xobject_dict.append_unsigned (idx);

    xobject_dict.append_c (' ');

    xobject_dict.append_unsigned (obj_id);

    xobject_dict.append_str (" 0 R ");

    return idx;

  }

};

/* Store resources pointer in the paint struct's defs buffer

 * (repurposed — defs is unused for PDF). */

static hb_pdf_resources_t *

hb_pdf_get_resources (hb_vector_paint_t *paint)

{

  if (!paint->defs.length)

  {

    /* First call: allocate and store. */

    auto *res = (hb_pdf_resources_t *) hb_calloc (1, sizeof (hb_pdf_resources_t));

    if (unlikely (!res)) return nullptr;

    new (res) hb_pdf_resources_t ();

    if (unlikely (!paint->defs.resize (sizeof (void *))))

    {

      res->~hb_pdf_resources_t ();

      hb_free (res);

      return nullptr;

    }

    memcpy (paint->defs.arrayZ, &res, sizeof (void *));

  }

  hb_pdf_resources_t *res;

  memcpy (&res, paint->defs.arrayZ, sizeof (void *));

  return res;

}

void

hb_vector_paint_pdf_free_resources (hb_vector_paint_t *paint)

{

  if (paint->defs.length >= sizeof (void *))

  {

    hb_pdf_resources_t *res;

    memcpy (&res, paint->defs.arrayZ, sizeof (void *));

    if (res)

    {

      res->~hb_pdf_resources_t ();

      hb_free (res);

    }

  }

  paint->defs.clear ();

}

/* ---- helpers ---- */

/* Emit a glyph outline as PDF path operators into buf. */

static void

hb_pdf_emit_glyph_path (hb_vector_paint_t *paint,

       hb_font_t *font,

       hb_codepoint_t glyph,

       hb_vector_buf_t *buf)

{

  hb_vector_path_sink_t sink = {&paint->path, paint->get_precision (),

             paint->x_scale_factor, paint->y_scale_factor};

  paint->path.clear ();

  hb_font_draw_glyph (font, glyph,

           hb_vector_pdf_path_draw_funcs_get (),

           &sink);

  buf->append_len (paint->path.arrayZ, paint->path.length);

  paint->path.clear ();

}

/* ---- paint callbacks ---- */

static void

hb_pdf_paint_push_transform (hb_paint_funcs_t *,

           void *paint_data,

           float xx, float yx,

           float xy, float yy,

           float dx, float dy,

           void *)

{

  auto *paint = (hb_vector_paint_t *) paint_data;

  if (unlikely (!paint->ensure_initialized ()))

    return;

  auto &body = paint->current_body ();

  unsigned sprec = body.scale_precision ();

  body.append_str ("q\n");

  body.append_num (xx, sprec);

  body.append_c (' ');

  body.append_num (yx, sprec);

  body.append_c (' ');

  body.append_num (xy, sprec);

  body.append_c (' ');

  body.append_num (yy, sprec);

  body.append_c (' ');

  body.append_num (paint->sx (dx));

  body.append_c (' ');

  body.append_num (paint->sy (dy));

  body.append_str (" cm\n");

}

static void

hb_pdf_paint_pop_transform (hb_paint_funcs_t *,

          void *paint_data,

          void *)

{

  auto *paint = (hb_vector_paint_t *) paint_data;

  if (unlikely (!paint->ensure_initialized ()))

    return;

  paint->current_body ().append_str ("Q\n");

}

static void

hb_pdf_paint_push_clip_glyph (hb_paint_funcs_t *,

            void *paint_data,

            hb_codepoint_t glyph,

            hb_font_t *font,

            void *)

{

  auto *paint = (hb_vector_paint_t *) paint_data;

  if (unlikely (!paint->ensure_initialized ()))

    return;

  auto &body = paint->current_body ();

  body.append_str ("q\n");

  hb_pdf_emit_glyph_path (paint, font, glyph, &body);

  body.append_str ("W n\n");

}

static void

hb_pdf_paint_push_clip_rectangle (hb_paint_funcs_t *,

          void *paint_data,

          float xmin, float ymin,

          float xmax, float ymax,

          void *)

{

  auto *paint = (hb_vector_paint_t *) paint_data;

  if (unlikely (!paint->ensure_initialized ()))

    return;

  auto &body = paint->current_body ();

  body.append_str ("q\n");

  body.append_num (paint->sx (xmin));

  body.append_c (' ');

  body.append_num (paint->sy (ymin));

  body.append_c (' ');

  body.append_num (paint->sx (xmax - xmin));

  body.append_c (' ');

  body.append_num (paint->sy (ymax - ymin));

  body.append_str (" re W n\n");

}

static hb_draw_funcs_t *

hb_pdf_paint_push_clip_path_start (hb_paint_funcs_t *,

           void *paint_data,

           void **draw_data,

           void *)

{

  auto *paint = (hb_vector_paint_t *) paint_data;

  if (unlikely (!paint->ensure_initialized ()))

  {

    *draw_data = nullptr;

    return nullptr;

  }

  auto &body = paint->current_body ();

  body.append_str ("q\n");

  /* Stream path operators straight into the body; end() seals

   * the path with "W n" to turn it into the clip region.

   * Coordinates arrive in font-scale; the sink divides by

   * scale_factor so they land in output space. */

  paint->clip_path_sink = {&body, paint->get_precision (),

         paint->x_scale_factor,

         paint->y_scale_factor};

  *draw_data = &paint->clip_path_sink;

  return hb_vector_pdf_path_draw_funcs_get ();

}

static void

hb_pdf_paint_push_clip_path_end (hb_paint_funcs_t *,

         void *paint_data,

         void *)

{

  auto *paint = (hb_vector_paint_t *) paint_data;

  if (unlikely (!paint->ensure_initialized ()))

    return;

  paint->current_body ().append_str ("W n\n");

}

static void

hb_pdf_paint_pop_clip (hb_paint_funcs_t *,

           void *paint_data,

           void *)

{

  auto *paint = (hb_vector_paint_t *) paint_data;

  if (unlikely (!paint->ensure_initialized ()))

    return;

  paint->current_body ().append_str ("Q\n");

}

/* Paint a solid color, including alpha via ExtGState. */

static void

hb_pdf_paint_solid_color (hb_vector_paint_t *paint, hb_color_t c)

{

  auto &body = paint->current_body ();

  float r = hb_color_get_red (c) / 255.f;

  float g = hb_color_get_green (c) / 255.f;

  float b = hb_color_get_blue (c) / 255.f;

  float a = hb_color_get_alpha (c) / 255.f;

  if (a < 1.f / 255.f)

    return;

  /* Set alpha via ExtGState if needed. */

  if (a < 1.f - 1.f / 512.f)

  {

    auto *res = hb_pdf_get_resources (paint);

    if (res)

    {

      unsigned gs_idx = res->add_extgstate_alpha (a);

      body.append_str ("/GS");

      body.append_unsigned (gs_idx);

      body.append_str (" gs\n");

    }

  }

  /* Set fill color. */

  body.append_num (r, 4);

  body.append_c (' ');

  body.append_num (g, 4);

  body.append_c (' ');

  body.append_num (b, 4);

  body.append_str (" rg\n");

  /* Paint a huge rect (will be clipped). */

  body.append_str ("-32767 -32767 65534 65534 re f\n");

}

static void

hb_pdf_paint_color (hb_paint_funcs_t *,

        void *paint_data,

        hb_bool_t,

        hb_color_t color,

        void *)

{

  auto *paint = (hb_vector_paint_t *) paint_data;

  if (unlikely (!paint->ensure_initialized ()))

    return;

  hb_pdf_paint_solid_color (paint, color);

}

/* Build an uncompressed alpha mask from indexed PNG IDAT data + tRNS.

 * Decompresses IDAT, un-filters PNG rows, maps palette indices to alpha. */

static bool

hb_pdf_build_indexed_smask (hb_vector_buf_t *out,

          const char *idat_data, unsigned idat_len,

          unsigned width, unsigned height,

          const uint8_t *trns, unsigned trns_len)

{

#ifndef HAVE_ZLIB

  (void) out; (void) idat_data; (void) idat_len;

  (void) width; (void) height; (void) trns; (void) trns_len;

  return false;

#else

  /* Decompress IDAT (zlib). */

  unsigned raw_len = (width + 1) * height; /* 1 filter byte per row + width bytes */

  uint8_t *raw = (uint8_t *) hb_malloc (raw_len);

  if (!raw) return false;

  HB_SCOPE_GUARD (hb_free (raw));

  z_stream stream = {};

  stream.next_in = (Bytef *) idat_data;

  stream.avail_in = idat_len;

  stream.next_out = (Bytef *) raw;

  stream.avail_out = raw_len;

  if (inflateInit (&stream) != Z_OK)

    return false;

  int status = inflate (&stream, Z_FINISH);

  unsigned long total_out = stream.total_out;

  inflateEnd (&stream);

  if (status != Z_STREAM_END || total_out != raw_len)

    return false;

  /* Un-filter and map to alpha. */

  if (!out->resize (width * height))

    return false;

  uint8_t *unfiltered = (uint8_t *) hb_malloc (width);

  if (!unfiltered)

    return false;

  HB_SCOPE_GUARD (hb_free (unfiltered));

  uint8_t *prev_unfiltered = (uint8_t *) hb_calloc (width, 1);

  if (!prev_unfiltered)

    return false;

  HB_SCOPE_GUARD (hb_free (prev_unfiltered));

  for (unsigned y = 0; y < height; y++)

  {

    uint8_t *row = raw + y * (width + 1);

    uint8_t filter = row[0];

    uint8_t *pixels = row + 1;

    for (unsigned x = 0; x < width; x++)

    {

      uint8_t a = (x > 0) ? unfiltered[x - 1] : 0;

      uint8_t b = prev_unfiltered[x];

      uint8_t c = (x > 0) ? prev_unfiltered[x - 1] : 0;

      uint8_t val = pixels[x];

      switch (filter)

      {

      case 0: unfiltered[x] = val; break; /* None */

      case 1: unfiltered[x] = val + a; break; /* Sub */

      case 2: unfiltered[x] = val + b; break; /* Up */

      case 3: unfiltered[x] = val + (uint8_t) (((unsigned) a + b) / 2); break; /* Average */

      case 4: /* Paeth */

      {

  int p = (int) a + (int) b - (int) c;

  int pa = abs (p - (int) a);

  int pb = abs (p - (int) b);

  int pc = abs (p - (int) c);

  uint8_t pr = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;

  unfiltered[x] = val + pr;

  break;

      }

      default: unfiltered[x] = val; break;

      }

      /* Map palette index to alpha. */

      uint8_t idx = unfiltered[x];

      out->arrayZ[y * width + x] = (idx < trns_len) ? trns[idx] : 0xFF;

    }

    /* Swap buffers. */

    uint8_t *tmp = prev_unfiltered;

    prev_unfiltered = unfiltered;

    unfiltered = tmp;

  }

  return true;

#endif

}

/* Read a big-endian uint32 from a byte pointer. */

static inline uint32_t

hb_pdf_png_u32 (const uint8_t *p)

{

  return ((uint32_t) p[0] << 24) | ((uint32_t) p[1] << 16) |

   ((uint32_t) p[2] << 8)  | (uint32_t) p[3];

}

static hb_bool_t

hb_pdf_paint_image (hb_paint_funcs_t *,

        void *paint_data,

        hb_blob_t *image,

        unsigned width,

        unsigned height,

        hb_tag_t format,

        float slant HB_UNUSED,

        hb_glyph_extents_t *extents,

        void *)

{

  if (format != HB_TAG ('p','n','g',' '))

    return false;

  if (!extents || !width || !height)

    return false;

  auto *paint = (hb_vector_paint_t *) paint_data;

  if (unlikely (!paint->ensure_initialized ()))

    return false;

  auto *res = hb_pdf_get_resources (paint);

  if (unlikely (!res))

    return false;

  unsigned len = 0;

  const uint8_t *data = (const uint8_t *) hb_blob_get_data (image, &len);

  if (!data || len < 8)

    return false;

  /* Verify PNG signature. */

  static const uint8_t png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};

  if (hb_memcmp (data, png_sig, 8) != 0)

    return false;

  /* Parse PNG chunks: extract IHDR and concatenate IDAT payloads. */

  unsigned png_w = 0, png_h = 0;

  unsigned colors = 3; /* default RGB */

  uint8_t color_type = 2;

  bool has_alpha = false;

  const uint8_t *plte_data = nullptr;

  unsigned plte_len = 0;

  const uint8_t *trns_data = nullptr;

  unsigned trns_len = 0;

  hb_vector_buf_t idat;

  unsigned pos = 8;

  while (pos + 12 <= len)

  {

    uint32_t chunk_len = hb_pdf_png_u32 (data + pos);

    uint32_t chunk_type = hb_pdf_png_u32 (data + pos + 4);

    if (pos + 12 + chunk_len > len)

      break;

    const uint8_t *chunk_data = data + pos + 8;

    if (chunk_type == 0x49484452u) /* IHDR */

    {

      if (chunk_len < 13) return false;

      png_w = hb_pdf_png_u32 (chunk_data);

      png_h = hb_pdf_png_u32 (chunk_data + 4);

      uint8_t bit_depth = chunk_data[8];

      color_type = chunk_data[9];

      if (bit_depth != 8) return false; /* only 8-bit supported */

      switch (color_type)

      {

      case 0: colors = 1; has_alpha = false; break; /* Grayscale */

      case 2: colors = 3; has_alpha = false; break; /* RGB */

      case 3: colors = 1; has_alpha = false; break; /* Indexed */

      case 4: colors = 2; has_alpha = true;  break; /* Gray+Alpha */

      case 6: colors = 4; has_alpha = true;  break; /* RGBA */

      default: return false;

      }

    }

    else if (chunk_type == 0x504C5445u) /* PLTE */

    {

      plte_data = chunk_data;

      plte_len = chunk_len;

    }

    else if (chunk_type == 0x74524E53u) /* tRNS */

    {

      trns_data = chunk_data;

      trns_len = chunk_len;

    }

    else if (chunk_type == 0x49444154u) /* IDAT */

    {

      idat.append_len ((const char *) chunk_data, chunk_len);

    }

    else if (chunk_type == 0x49454E44u) /* IEND */

      break;

    pos += 12 + chunk_len;

  }

  if (!png_w || !png_h || !idat.length)

    return false;

  unsigned im_idx = res->add_xobject_png_image (idat.arrayZ, idat.length,

             png_w, png_h,

             colors, has_alpha,

             plte_data, plte_len,

             trns_data, trns_len);

  /* Emit: save state, set CTM to map image (0,0)-(1,1) to extents, paint. */

  auto &body = paint->current_body ();

  body.append_str ("q\n");

  /* Image space: (0,0) at bottom-left, (1,1) at top-right.

   * We need to map to extents (x_bearing, y_bearing+height) .. (x_bearing+width, y_bearing).

   * Since font coords are Y-up like PDF, y_bearing is the top. */

  float ix = (float) extents->x_bearing;

  float iy = (float) extents->y_bearing + (float) extents->height;

  float iw = (float) extents->width;

  float ih = (float) -extents->height; /* negative because image Y goes up but height is negative in extents */

  body.append_num (paint->sx (iw));

  body.append_str (" 0 0 ");

  body.append_num (paint->sy (ih));

  body.append_c (' ');

  body.append_num (paint->sx (ix));

  body.append_c (' ');

  body.append_num (paint->sy (iy));

  body.append_str (" cm\n");

  body.append_str ("/Im");

  body.append_unsigned (im_idx);

  body.append_str (" Do\nQ\n");

  return true;

}

/* ---- Gradient helpers ---- */

static bool

hb_pdf_gradient_needs_alpha (hb_array_t<const hb_color_stop_t> stops)

{

  for (const auto &s : stops)

    if (hb_color_get_alpha (s.color) != 255)

      return true;

  return false;

}

/* Build a PDF Type 2 (exponential interpolation) function for

 * a single alpha stop pair (DeviceGray, scalar output). */

static void

hb_pdf_build_alpha_interpolation_function (hb_vector_buf_t *obj,

             float a0, float a1)

{

  obj->append_str ("<< /FunctionType 2 /Domain [0 1] /N 1\n");

  obj->append_str ("/C0 [");

  obj->append_num (a0, 4);

  obj->append_str ("]\n/C1 [");

  obj->append_num (a1, 4);

  obj->append_str ("] >>");

}

/* Build a stitching function (Type 3) for the alpha channel of

 * pre-populated paint->color_stops_scratch (already sorted+normalized). */

static unsigned

hb_pdf_build_alpha_gradient_function_from_stops (hb_pdf_resources_t *res,

             hb_vector_paint_t *paint)

{

  unsigned count = paint->color_stops_scratch.length;

  if (count < 2)

  {

    float a = count ? hb_color_get_alpha (paint->color_stops_scratch.arrayZ[0].color) / 255.f : 1.f;

    hb_vector_buf_t obj;

    hb_pdf_build_alpha_interpolation_function (&obj, a, a);

    return res->add_object (std::move (obj));

  }

  if (count == 2)

  {

    hb_vector_buf_t obj;

    hb_pdf_build_alpha_interpolation_function (&obj,

      hb_color_get_alpha (paint->color_stops_scratch.arrayZ[0].color) / 255.f,

      hb_color_get_alpha (paint->color_stops_scratch.arrayZ[1].color) / 255.f);

    return res->add_object (std::move (obj));

  }

  hb_vector_t<unsigned> sub_func_ids;

  for (unsigned i = 0; i + 1 < count; i++)

  {

    hb_vector_buf_t sub;

    hb_pdf_build_alpha_interpolation_function (&sub,

      hb_color_get_alpha (paint->color_stops_scratch.arrayZ[i].color) / 255.f,

      hb_color_get_alpha (paint->color_stops_scratch.arrayZ[i + 1].color) / 255.f);

    sub_func_ids.push (res->add_object (std::move (sub)));

  }

  hb_vector_buf_t obj;

  obj.append_str ("<< /FunctionType 3 /Domain [0 1]\n");

  obj.append_str ("/Functions [");

  for (unsigned i = 0; i < sub_func_ids.length; i++)

  {

    if (i) obj.append_c (' ');

    obj.append_unsigned (sub_func_ids.arrayZ[i]);

    obj.append_str (" 0 R");

  }

  obj.append_str ("]\n/Bounds [");

  for (unsigned i = 1; i + 1 < count; i++)

  {

    if (i > 1) obj.append_c (' ');

    obj.append_num (paint->color_stops_scratch.arrayZ[i].offset, 4);

  }

  obj.append_str ("]\n/Encode [");

  for (unsigned i = 0; i + 1 < count; i++)

  {

    if (i) obj.append_c (' ');

    obj.append_str ("0 1");

  }

  obj.append_str ("] >>");

  return res->add_object (std::move (obj));

}

/* Build a PDF Type 2 (exponential interpolation) function for

 * a single color stop pair. */

static void

hb_pdf_build_interpolation_function (hb_vector_buf_t *obj,

             hb_color_t c0, hb_color_t c1)

{

  obj->append_str ("<< /FunctionType 2 /Domain [0 1] /N 1\n");

  obj->append_str ("/C0 [");

  obj->append_num (hb_color_get_red (c0) / 255.f, 4);

  obj->append_c (' ');

  obj->append_num (hb_color_get_green (c0) / 255.f, 4);

  obj->append_c (' ');

  obj->append_num (hb_color_get_blue (c0) / 255.f, 4);

  obj->append_str ("]\n/C1 [");

  obj->append_num (hb_color_get_red (c1) / 255.f, 4);

  obj->append_c (' ');

  obj->append_num (hb_color_get_green (c1) / 255.f, 4);

  obj->append_c (' ');

  obj->append_num (hb_color_get_blue (c1) / 255.f, 4);

  obj->append_str ("] >>");

}

/* Build a stitching function (Type 3) from pre-populated

 * paint->color_stops_scratch (already sorted+normalized). */

static unsigned

hb_pdf_build_gradient_function_from_stops (hb_pdf_resources_t *res,

             hb_vector_paint_t *paint)

{

  unsigned count = paint->color_stops_scratch.length;

  if (count < 2)

  {

    /* Single stop: constant function. */

    hb_color_t c = count ? paint->color_stops_scratch.arrayZ[0].color

       : HB_COLOR (0, 0, 0, 255);

    hb_vector_buf_t obj;

    hb_pdf_build_interpolation_function (&obj, c, c);

    return res->add_object (std::move (obj));

  }

  /* Sort by offset. */

  paint->color_stops_scratch.as_array ().qsort (

    [] (const hb_color_stop_t &a, const hb_color_stop_t &b)

    { return (a.offset > b.offset) - (a.offset < b.offset); });

  if (count == 2)

  {

    /* Two stops: single interpolation function. */

    hb_vector_buf_t obj;

    hb_pdf_build_interpolation_function (&obj,

            paint->color_stops_scratch.arrayZ[0].color,

            paint->color_stops_scratch.arrayZ[1].color);

    return res->add_object (std::move (obj));

  }

  /* Multiple stops: create sub-functions and stitch. */

  hb_vector_t<unsigned> sub_func_ids;

  for (unsigned i = 0; i + 1 < count; i++)

  {

    hb_vector_buf_t sub;

    hb_pdf_build_interpolation_function (&sub,

            paint->color_stops_scratch.arrayZ[i].color,

            paint->color_stops_scratch.arrayZ[i + 1].color);

    sub_func_ids.push (res->add_object (std::move (sub)));

  }

  /* Stitching function (Type 3). */

  hb_vector_buf_t obj;

  obj.append_str ("<< /FunctionType 3 /Domain [0 1]\n");

  /* Functions array. */

  obj.append_str ("/Functions [");

  for (unsigned i = 0; i < sub_func_ids.length; i++)

  {

    if (i) obj.append_c (' ');

    obj.append_unsigned (sub_func_ids.arrayZ[i]);

    obj.append_str (" 0 R");

  }

  obj.append_str ("]\n");

  /* Bounds. */

  obj.append_str ("/Bounds [");

  for (unsigned i = 1; i + 1 < count; i++)

  {

    if (i > 1) obj.append_c (' ');

    obj.append_num (paint->color_stops_scratch.arrayZ[i].offset, 4);

  }

  obj.append_str ("]\n");

  /* Encode array. */

  obj.append_str ("/Encode [");

  for (unsigned i = 0; i + 1 < count; i++)

  {

    if (i) obj.append_c (' ');

    obj.append_str ("0 1");

  }

  obj.append_str ("] >>");

  return res->add_object (std::move (obj));

}

static void

hb_pdf_paint_linear_gradient (hb_paint_funcs_t *,

            void *paint_data,

            hb_color_line_t *color_line,

            float x0, float y0,

            float x1, float y1,

            float x2 HB_UNUSED, float y2 HB_UNUSED,

            void *)

{

  auto *paint = (hb_vector_paint_t *) paint_data;

  if (unlikely (!paint->ensure_initialized ()))

    return;

  auto *res = hb_pdf_get_resources (paint);

  if (unlikely (!res))

    return;

  /* Fetch, normalize stops to [0,1], and adjust coordinates. */

  if (!paint->fetch_color_stops (color_line))

    return;

  hb_vector_t<hb_color_stop_t> &stops = paint->color_stops_scratch;

  float mn, mx;

  hb_paint_normalize_color_line (stops.arrayZ, stops.length, &mn, &mx);

  float gx0 = x0 + mn * (x1 - x0);

  float gy0 = y0 + mn * (y1 - y0);

  float gx1 = x0 + mx * (x1 - x0);

  float gy1 = y0 + mx * (y1 - y0);

  unsigned func_id = hb_pdf_build_gradient_function_from_stops (res, paint);

  hb_paint_extend_t extend = hb_color_line_get_extend (color_line);

  const char *extend_str = (extend == HB_PAINT_EXTEND_PAD)

          ? "/Extend [true true]\n" : "";

  /* Build Type 2 (axial) shading — color only. */

  hb_vector_buf_t sh;

  sh.append_str ("<< /ShadingType 2 /ColorSpace /DeviceRGB\n");

  sh.append_str ("/Coords [");

  sh.append_num (paint->sx (gx0));

  sh.append_c (' ');

  sh.append_num (paint->sy (gy0));

  sh.append_c (' ');

  sh.append_num (paint->sx (gx1));

  sh.append_c (' ');

  sh.append_num (paint->sy (gy1));

  sh.append_str ("]\n/Function ");

  sh.append_unsigned (func_id);

  sh.append_str (" 0 R\n");

  sh.append_str (extend_str);

  sh.append_str (">>");

  unsigned sh_idx = res->add_shading (std::move (sh));

  auto &body = paint->current_body ();

  bool needs_alpha = hb_pdf_gradient_needs_alpha (stops);

  if (needs_alpha)

  {

    unsigned alpha_func_id = hb_pdf_build_alpha_gradient_function_from_stops (res, paint);

    hb_vector_buf_t ash;

    ash.append_str ("<< /ShadingType 2 /ColorSpace /DeviceGray\n");

    ash.append_str ("/Coords [");

    ash.append_num (paint->sx (gx0));

    ash.append_c (' ');

    ash.append_num (paint->sy (gy0));

    ash.append_c (' ');

    ash.append_num (paint->sx (gx1));

    ash.append_c (' ');

    ash.append_num (paint->sy (gy1));

    ash.append_str ("]\n/Function ");

    ash.append_unsigned (alpha_func_id);

    ash.append_str (" 0 R\n");

    ash.append_str (extend_str);

    ash.append_str (">>");

    unsigned alpha_sh_id = res->add_object (std::move (ash));

    unsigned gs_idx = res->add_extgstate_smask (alpha_sh_id,

            paint->sx (gx0), paint->sy (gy0),

            paint->sx (gx1 - gx0), paint->sy (gy1 - gy0),

            paint->get_precision ());

    body.append_str ("/GS");

    body.append_unsigned (gs_idx);