// Copyright (C) 2004-2021 Artifex Software, Inc.

//

// This file is part of MuPDF.

//

// MuPDF is free software: you can redistribute it and/or modify it under the

// terms of the GNU Affero General Public License as published by the Free

// Software Foundation, either version 3 of the License, or (at your option)

// any later version.

//

// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY

// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more

// details.

//

// You should have received a copy of the GNU Affero General Public License

// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>

//

// Alternative licensing terms are available from the licensor.

// For commercial licensing, see <https://www.artifex.com/> or contact

// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,

// CA 94129, USA, for further information.

#include "mupdf/fitz.h"

#include "pixmap-imp.h"

#include "z-imp.h"

#include <limits.h>

#include <string.h>

struct info

{

  unsigned int width, height, depth, n;

  enum fz_colorspace_type type;

  int interlace, indexed;

  size_t size;

  unsigned char *samples;

  unsigned char palette[256*4];

  int transparency;

  int trns[3];

  int xres, yres;

  fz_colorspace *cs;

};

static inline int getcomp(const unsigned char *line, int x, int bpc)

{

  switch (bpc)

  {

  case 1: return (line[x >> 3] >> ( 7 - (x & 7) ) ) & 1;

  case 2: return (line[x >> 2] >> ( ( 3 - (x & 3) ) << 1 ) ) & 3;

  case 4: return (line[x >> 1] >> ( ( 1 - (x & 1) ) << 2 ) ) & 15;

  case 8: return line[x];

  case 16: return line[x << 1] << 8 | line[(x << 1) + 1];

  }

  return 0;

}

static inline void putcomp(unsigned char *line, int x, int bpc, int value)

{

  int maxval = (1 << bpc) - 1;

  switch (bpc)

  {

  case 1: line[x >> 3] &= ~(maxval << (7 - (x & 7))); break;

  case 2: line[x >> 2] &= ~(maxval << ((3 - (x & 3)) << 1)); break;

  case 4: line[x >> 1] &= ~(maxval << ((1 - (x & 1)) << 2)); break;

  }

  switch (bpc)

  {

  case 1: line[x >> 3] |= value << (7 - (x & 7)); break;

  case 2: line[x >> 2] |= value << ((3 - (x & 3)) << 1); break;

  case 4: line[x >> 1] |= value << ((1 - (x & 1)) << 2); break;

  case 8: line[x] = value; break;

  case 16: line[x << 1] = value >> 8; line[(x << 1) + 1] = value & 0xFF; break;

  }

}

static const unsigned char png_signature[8] =

{

  137, 80, 78, 71, 13, 10, 26, 10

};

static inline int paeth(int a, int b, int c)

{

  /* The definitions of ac and bc are correct, not a typo. */

  int ac = b - c, bc = a - c, abcc = ac + bc;

  int pa = (ac < 0 ? -ac : ac);

  int pb = (bc < 0 ? -bc : bc);

  int pc = (abcc < 0 ? -abcc : abcc);

  return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;

}

static void

png_predict(unsigned char *samples, unsigned int width, unsigned int height, unsigned int n, unsigned int depth)

{

  unsigned int stride = (width * n * depth + 7) / 8;

  unsigned int bpp = (n * depth + 7) / 8;

  unsigned int i, row;

  for (row = 0; row < height; row ++)

  {

    unsigned char *src = samples + (unsigned int)((stride + 1) * row);

    unsigned char *dst = samples + (unsigned int)(stride * row);

    unsigned char *a = dst;

    unsigned char *b = dst - stride;

    unsigned char *c = dst - stride;

    switch (*src++)

    {

    default:

    case 0: /* None */

      for (i = 0; i < stride; i++)

        *dst++ = *src++;

      break;

    case 1: /* Sub */

      for (i = 0; i < bpp; i++)

        *dst++ = *src++;

      for (i = bpp; i < stride; i++)

        *dst++ = *src++ + *a++;

      break;

    case 2: /* Up */

      if (row == 0)

        for (i = 0; i < stride; i++)

          *dst++ = *src++;

      else

        for (i = 0; i < stride; i++)

          *dst++ = *src++ + *b++;

      break;

    case 3: /* Average */

      if (row == 0)

      {

        for (i = 0; i < bpp; i++)

          *dst++ = *src++;

        for (i = bpp; i < stride; i++)

          *dst++ = *src++ + (*a++ >> 1);

      }

      else

      {

        for (i = 0; i < bpp; i++)

          *dst++ = *src++ + (*b++ >> 1);

        for (i = bpp; i < stride; i++)

          *dst++ = *src++ + ((*b++ + *a++) >> 1);

      }

      break;

    case 4: /* Paeth */

      if (row == 0)

      {

        for (i = 0; i < bpp; i++)

          *dst++ = *src++ + paeth(0, 0, 0);

        for (i = bpp; i < stride; i++)

          *dst++ = *src++ + paeth(*a++, 0, 0);

      }

      else

      {

        for (i = 0; i < bpp; i++)

          *dst++ = *src++ + paeth(0, *b++, 0);

        for (i = bpp; i < stride; i++)

          *dst++ = *src++ + paeth(*a++, *b++, *c++);

      }

      break;

    }

  }

}

static const unsigned int adam7_ix[7] = { 0, 4, 0, 2, 0, 1, 0 };

static const unsigned int adam7_dx[7] = { 8, 8, 4, 4, 2, 2, 1 };

static const unsigned int adam7_iy[7] = { 0, 0, 4, 0, 2, 0, 1 };

static const unsigned int adam7_dy[7] = { 8, 8, 8, 4, 4, 2, 2 };

static void

png_deinterlace_passes(fz_context *ctx, struct info *info, unsigned int *w, unsigned int *h, unsigned int *ofs)

{

  int p, bpp = info->depth * info->n;

  ofs[0] = 0;

  for (p = 0; p < 7; p++)

  {

    w[p] = (info->width + adam7_dx[p] - adam7_ix[p] - 1) / adam7_dx[p];

    h[p] = (info->height + adam7_dy[p] - adam7_iy[p] - 1) / adam7_dy[p];

    if (w[p] == 0) h[p] = 0;

    if (h[p] == 0) w[p] = 0;

    if (w[p] && h[p])

      ofs[p + 1] = ofs[p] + h[p] * (1 + (w[p] * bpp + 7) / 8);

    else

      ofs[p + 1] = ofs[p];

  }

}

static void

png_deinterlace(fz_context *ctx, struct info *info, unsigned int *passw, unsigned int *passh, unsigned int *passofs)

{

  unsigned int n = info->n;

  unsigned int depth = info->depth;

  size_t stride = ((size_t)info->width * n * depth + 7) / 8;

  unsigned char *output;

  unsigned int p, x, y, k;

  if (info->height > UINT_MAX / stride)

    fz_throw(ctx, FZ_ERROR_LIMIT, "image too large");

  output = Memento_label(fz_malloc(ctx, info->height * stride), "png_deinterlace");

  for (p = 0; p < 7; p++)

  {

    unsigned char *sp = info->samples + (passofs[p]);

    unsigned int w = passw[p];

    unsigned int h = passh[p];

    png_predict(sp, w, h, n, depth);

    for (y = 0; y < h; y++)

    {

      for (x = 0; x < w; x++)

      {

        int outx = x * adam7_dx[p] + adam7_ix[p];

        int outy = y * adam7_dy[p] + adam7_iy[p];

        unsigned char *dp = output + outy * stride;

        for (k = 0; k < n; k++)

        {

          int v = getcomp(sp, x * n + k, depth);

          putcomp(dp, outx * n + k, depth, v);

        }

      }

      sp += (w * depth * n + 7) / 8;

    }

  }

  fz_free(ctx, info->samples);

  info->samples = output;

}

static void

png_read_ihdr(fz_context *ctx, struct info *info, const unsigned char *p, unsigned int size)

{

  int color, compression, filter;

  if (size != 13)

    fz_throw(ctx, FZ_ERROR_FORMAT, "IHDR chunk is the wrong size");

  info->width = fz_unpack_uint32(p + 0);

  info->height = fz_unpack_uint32(p + 4);

  info->depth = p[8];

  color = p[9];

  compression = p[10];

  filter = p[11];

  info->interlace = p[12];

  if (info->width <= 0)

    fz_throw(ctx, FZ_ERROR_FORMAT, "image width must be > 0");

  if (info->height <= 0)

    fz_throw(ctx, FZ_ERROR_FORMAT, "image height must be > 0");

  if (info->depth != 1 && info->depth != 2 && info->depth != 4 &&

      info->depth != 8 && info->depth != 16)

    fz_throw(ctx, FZ_ERROR_FORMAT, "image bit depth must be one of 1, 2, 4, 8, 16");

  if (color == 2 && info->depth < 8)

    fz_throw(ctx, FZ_ERROR_FORMAT, "illegal bit depth for truecolor");

  if (color == 3 && info->depth > 8)

    fz_throw(ctx, FZ_ERROR_FORMAT, "illegal bit depth for indexed");

  if (color == 4 && info->depth < 8)

    fz_throw(ctx, FZ_ERROR_FORMAT, "illegal bit depth for grayscale with alpha");

  if (color == 6 && info->depth < 8)

    fz_throw(ctx, FZ_ERROR_FORMAT, "illegal bit depth for truecolor with alpha");

  info->indexed = 0;

  if (color == 0) /* gray */

    info->n = 1, info->type = FZ_COLORSPACE_GRAY;

  else if (color == 2) /* rgb */

    info->n = 3, info->type = FZ_COLORSPACE_RGB;

  else if (color == 4) /* gray alpha */

    info->n = 2, info->type = FZ_COLORSPACE_GRAY;

  else if (color == 6) /* rgb alpha */

    info->n = 4, info->type = FZ_COLORSPACE_RGB;

  else if (color == 3) /* indexed */

  {

    info->type = FZ_COLORSPACE_RGB; /* after colorspace expansion it will be */

    info->indexed = 1;

    info->n = 1;

  }

  else

    fz_throw(ctx, FZ_ERROR_FORMAT, "unknown color type");

  if (compression != 0)

    fz_throw(ctx, FZ_ERROR_FORMAT, "unknown compression method");

  if (filter != 0)

    fz_throw(ctx, FZ_ERROR_FORMAT, "unknown filter method");

  if (info->interlace != 0 && info->interlace != 1)

    fz_throw(ctx, FZ_ERROR_FORMAT, "interlace method not supported");

  if (info->height > UINT_MAX / info->width / info->n / (info->depth / 8 + 1))

    fz_throw(ctx, FZ_ERROR_LIMIT, "image dimensions might overflow");

}

static void

png_read_plte(fz_context *ctx, struct info *info, const unsigned char *p, unsigned int size)

{

  int n = size / 3;

  int i;

  if (n > 256)

  {

    fz_warn(ctx, "too many samples in palette");

    n = 256;

  }

  for (i = 0; i < n; i++)

  {

    info->palette[i * 4] = p[i * 3];

    info->palette[i * 4 + 1] = p[i * 3 + 1];

    info->palette[i * 4 + 2] = p[i * 3 + 2];

  }

  /* Fill in any missing palette entries */

  for (; i < 256; i++)

  {

    info->palette[i * 4] = 0;

    info->palette[i * 4 + 1] = 0;

    info->palette[i * 4 + 2] = 0;

  }

}

static void

png_read_trns(fz_context *ctx, struct info *info, const unsigned char *p, unsigned int size)

{

  unsigned int i;

  info->transparency = 1;

  if (info->indexed)

  {

    if (size > 256)

    {

      fz_warn(ctx, "too many samples in transparency table");

      size = 256;

    }

    for (i = 0; i < size; i++)

      info->palette[i * 4 + 3] = p[i];

    /* Fill in any missing entries */

    for (; i < 256; i++)

      info->palette[i * 4 + 3] = 255;

  }

  else

  {

    if (size != info->n * 2)

      fz_throw(ctx, FZ_ERROR_FORMAT, "tRNS chunk is the wrong size");

    for (i = 0; i < info->n; i++)

      info->trns[i] = (p[i * 2] << 8 | p[i * 2 + 1]) & ((1 << info->depth) - 1);

  }

}

static void

png_read_icc(fz_context *ctx, struct info *info, const unsigned char *p, unsigned int size)

{

#if FZ_ENABLE_ICC

  fz_stream *mstm = NULL, *zstm = NULL;

  fz_colorspace *cs = NULL;

  fz_buffer *buf = NULL;

  size_t m = fz_mini(80, size);

  size_t n = fz_strnlen((const char *)p, m);

  if (n + 2 > m)

  {

    fz_warn(ctx, "invalid ICC profile name");

    return;

  }

  fz_var(mstm);

  fz_var(zstm);

  fz_var(buf);

  fz_try(ctx)

  {

    mstm = fz_open_memory(ctx, p + n + 2, size - n - 2);

    zstm = fz_open_flated(ctx, mstm, 15);

    buf = fz_read_all(ctx, zstm, 0);

    cs = fz_new_icc_colorspace(ctx, info->type, 0, NULL, buf);

    fz_drop_colorspace(ctx, info->cs);

    info->cs = cs;

  }

  fz_always(ctx)

  {

    fz_drop_buffer(ctx, buf);

    fz_drop_stream(ctx, zstm);

    fz_drop_stream(ctx, mstm);

  }

  fz_catch(ctx)

  {

    fz_rethrow_if(ctx, FZ_ERROR_SYSTEM);

    fz_report_error(ctx);

    fz_warn(ctx, "ignoring embedded ICC profile in PNG");

  }

#endif

}

static void

png_read_idat(fz_context *ctx, struct info *info, const unsigned char *p, unsigned int size, z_stream *stm)

{

  int code;

  stm->next_in = (Bytef*)p;

  stm->avail_in = size;

  code = inflate(stm, Z_SYNC_FLUSH);

  if (code != Z_OK && code != Z_STREAM_END)

    fz_throw(ctx, FZ_ERROR_LIBRARY, "zlib error: %s", stm->msg);

  if (stm->avail_in != 0)

  {

    if (stm->avail_out == 0)

      fz_throw(ctx, FZ_ERROR_FORMAT, "ran out of output before input");

    fz_throw(ctx, FZ_ERROR_FORMAT, "inflate did not consume buffer (%d remaining)", stm->avail_in);

  }

}

static void

png_read_phys(fz_context *ctx, struct info *info, const unsigned char *p, unsigned int size)

{

  if (size != 9)

    fz_throw(ctx, FZ_ERROR_FORMAT, "pHYs chunk is the wrong size");

  if (p[8] == 1)

  {

    info->xres = (fz_unpack_uint32(p) * 254 + 5000) / 10000;

    info->yres = (fz_unpack_uint32(p + 4) * 254 + 5000) / 10000;

  }

}

static void

png_read_image(fz_context *ctx, struct info *info, const unsigned char *p, size_t total, int only_metadata)

{

  unsigned int passw[7], passh[7], passofs[8];

  unsigned int code, size;

  z_stream stm;

  memset(info, 0, sizeof (struct info));

  memset(info->palette, 255, sizeof(info->palette));

  info->xres = 96;

  info->yres = 96;

  /* Read signature */

  if (total < 8 + 12 || memcmp(p, png_signature, 8))

    fz_throw(ctx, FZ_ERROR_FORMAT, "not a png image (wrong signature)");

  p += 8;

  total -= 8;

  /* Read IHDR chunk (must come first) */

  size = fz_unpack_uint32(p);

  if (size > total - 12)

    fz_throw(ctx, FZ_ERROR_FORMAT, "premature end of data in png image");

  if (!memcmp(p + 4, "IHDR", 4))

    png_read_ihdr(ctx, info, p + 8, size);

  else

    fz_throw(ctx, FZ_ERROR_FORMAT, "png file must start with IHDR chunk");

  p += size + 12;

  total -= size + 12;

  /* Prepare output buffer */

  if (!only_metadata)

  {

    if (!info->interlace)

    {

      info->size = info->height * (1 + ((size_t) info->width * info->n * info->depth + 7) / 8);

    }

    else

    {

      png_deinterlace_passes(ctx, info, passw, passh, passofs);

      info->size = passofs[7];

    }

    info->samples = Memento_label(fz_malloc(ctx, info->size), "png_samples");

    stm.zalloc = fz_zlib_alloc;

    stm.zfree = fz_zlib_free;

    stm.opaque = ctx;

    stm.next_out = info->samples;

    stm.avail_out = (uInt)info->size;

    code = inflateInit(&stm);

    if (code != Z_OK)

      fz_throw(ctx, FZ_ERROR_LIBRARY, "zlib error: %s", stm.msg);

  }

  fz_try(ctx)

  {

    /* Read remaining chunks until IEND */

    while (total > 8)

    {

      size = fz_unpack_uint32(p);

      if (total < 12 || size > total - 12)

        fz_throw(ctx, FZ_ERROR_FORMAT, "premature end of data in png image");

      if (!memcmp(p + 4, "PLTE", 4) && !only_metadata)

        png_read_plte(ctx, info, p + 8, size);

      if (!memcmp(p + 4, "tRNS", 4) && !only_metadata)

        png_read_trns(ctx, info, p + 8, size);

      if (!memcmp(p + 4, "pHYs", 4))

        png_read_phys(ctx, info, p + 8, size);

      if (!memcmp(p + 4, "IDAT", 4) && !only_metadata)

        png_read_idat(ctx, info, p + 8, size, &stm);

      if (!memcmp(p + 4, "iCCP", 4))

        png_read_icc(ctx, info, p + 8, size);

      if (!memcmp(p + 4, "IEND", 4))

        break;

      p += size + 12;

      total -= size + 12;

    }

    if (!only_metadata && stm.avail_out != 0)

    {

      memset(stm.next_out, 0xff, stm.avail_out);

      fz_warn(ctx, "missing pixel data in png image; possibly truncated");

    }

    else if (total <= 8)

      fz_warn(ctx, "missing IEND chunk in png image; possibly truncated");

  }

  fz_catch(ctx)

  {

    if (!only_metadata)

    {

      inflateEnd(&stm);

      fz_free(ctx, info->samples);

      info->samples = NULL;

    }

    fz_rethrow(ctx);

  }

  if (!only_metadata)

  {

    code = inflateEnd(&stm);

    if (code != Z_OK)

    {

      fz_free(ctx, info->samples);

      info->samples = NULL;

      fz_throw(ctx, FZ_ERROR_LIBRARY, "zlib error: %s", stm.msg);

    }

    /* Apply prediction filter and deinterlacing */

    fz_try(ctx)

    {

      if (!info->interlace)

        png_predict(info->samples, info->width, info->height, info->n, info->depth);

      else

        png_deinterlace(ctx, info, passw, passh, passofs);

    }

    fz_catch(ctx)

    {

      fz_free(ctx, info->samples);

      info->samples = NULL;

      fz_rethrow(ctx);

    }

  }

  if (info->cs && fz_colorspace_type(ctx, info->cs) != info->type)

  {

    fz_warn(ctx, "embedded ICC profile does not match PNG colorspace");

    fz_drop_colorspace(ctx, info->cs);

    info->cs = NULL;

  }

  if (info->cs == NULL)

  {

    if (info->n == 3 || info->n == 4 || info->indexed)

      info->cs = fz_keep_colorspace(ctx, fz_device_rgb(ctx));

    else

      info->cs = fz_keep_colorspace(ctx, fz_device_gray(ctx));

  }

}

static fz_pixmap *

png_expand_palette(fz_context *ctx, struct info *info, fz_pixmap *src)

{

  fz_pixmap *dst = fz_new_pixmap(ctx, info->cs, src->w, src->h, NULL, info->transparency);

  unsigned char *sp = src->samples;

  unsigned char *dp = dst->samples;

  unsigned int x, y;

  size_t dstride = dst->stride - dst->w * (size_t)dst->n;

  size_t sstride = src->stride - src->w * (size_t)src->n;

  dst->xres = src->xres;

  dst->yres = src->yres;

  for (y = info->height; y > 0; y--)

  {

    for (x = info->width; x > 0; x--)

    {

      int v = *sp << 2;

      *dp++ = info->palette[v];

      *dp++ = info->palette[v + 1];

      *dp++ = info->palette[v + 2];

      if (info->transparency)

        *dp++ = info->palette[v + 3];

      ++sp;

    }

    sp += sstride;

    dp += dstride;

  }

  fz_drop_pixmap(ctx, src);

  return dst;

}

static void

png_mask_transparency(struct info *info, fz_pixmap *dst)

{

  unsigned int stride = (info->width * info->n * info->depth + 7) / 8;

  unsigned int depth = info->depth;

  unsigned int n = info->n;

  unsigned int x, y, k, t;

  for (y = 0; y < info->height; y++)

  {

    unsigned char *sp = info->samples + (unsigned int)(y * stride);

    unsigned char *dp = dst->samples + (unsigned int)(y * dst->stride);

    for (x = 0; x < info->width; x++)

    {

      t = 1;

      for (k = 0; k < n; k++)

        if (getcomp(sp, x * n + k, depth) != info->trns[k])

          t = 0;

      if (t)

        dp[x * dst->n + dst->n - 1] = 0;

    }

  }

}

fz_pixmap *

fz_load_png(fz_context *ctx, const unsigned char *p, size_t total)

{

  fz_pixmap *image = NULL;

  struct info png;

  size_t stride;

  int alpha;

  fz_var(image);

  fz_try(ctx)

  {

    png_read_image(ctx, &png, p, total, 0);

    stride = ((size_t) png.width * png.n * png.depth + 7) / 8;

    alpha = (png.n == 2 || png.n == 4 || png.transparency);

    if (png.indexed)

    {

      image = fz_new_pixmap(ctx, NULL, png.width, png.height, NULL, 1);

      fz_unpack_tile(ctx, image, png.samples, png.n, png.depth, stride, 1);

      image = png_expand_palette(ctx, &png, image);

    }

    else

    {

      image = fz_new_pixmap(ctx, png.cs, png.width, png.height, NULL, alpha);

      fz_unpack_tile(ctx, image, png.samples, png.n, png.depth, stride, 0);

      if (png.transparency)

        png_mask_transparency(&png, image);

    }

    if (alpha)

      fz_premultiply_pixmap(ctx, image);

    fz_set_pixmap_resolution(ctx, image, png.xres, png.yres);

  }

  fz_always(ctx)

  {

    fz_drop_colorspace(ctx, png.cs);

    fz_free(ctx, png.samples);

  }

  fz_catch(ctx)

  {

    fz_drop_pixmap(ctx, image);

    fz_rethrow(ctx);

  }

  return image;

}

void

fz_load_png_info(fz_context *ctx, const unsigned char *p, size_t total, int *wp, int *hp, int *xresp, int *yresp, fz_colorspace **cspacep)

{

  struct info png;

  fz_try(ctx)

    png_read_image(ctx, &png, p, total, 1);

  fz_catch(ctx)

  {

    fz_drop_colorspace(ctx, png.cs);

    fz_rethrow(ctx);

  }

  *cspacep = png.cs;

  *wp = png.width;

  *hp = png.height;

  *xresp = png.xres;

  *yresp = png.xres;

}