path: root/nxcompext/Pgn.c

/**************************************************************************/
/*                                                                        */
/* Copyright (c) 2001, 2007 NoMachine, http://www.nomachine.com/.         */
/*                                                                        */
/* NXCOMPEXT, NX protocol compression and NX extensions to this software  */
/* are copyright of NoMachine. Redistribution and use of the present      */
/* software is allowed according to terms specified in the file LICENSE   */
/* which comes in the source distribution.                                */
/*                                                                        */
/* Check http://www.nomachine.com/licensing.html for applicability.       */
/*                                                                        */
/* NX and NoMachine are trademarks of NoMachine S.r.l.                    */
/*                                                                        */
/* All rigths reserved.                                                   */
/*                                                                        */
/**************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "Xutil.h"

#include "NXlib.h"

#include "Mask.h"
#include "Pgn.h"

#define PANIC
#define WARNING
#undef  TEST
#undef  DEBUG

/*
 * Selected ZLIB compression level.
 */

#define PNG_Z_LEVEL   4

/*
 * Local function prototypes.
 */

static void PrepareRowForPng(CARD8 *dst, int y, int count);
static void PrepareRowForPng24(CARD8 *dst, int y, int count);
static void PrepareRowForPng16(CARD8 *dst, int y, int count);
static void PrepareRowForPng32(CARD8 *dst, int y, int count);

static void PngWriteData(png_structp png_ptr, png_bytep data, png_size_t length);
static void PngFlushData(png_structp png_ptr);

/*
 * Image characteristics.
 */

static int bytesPerLine;
static int byteOrder;

static CARD8 bitsPerPixel;
static CARD16 redMax, greenMax, blueMax;
static CARD8 redShift, greenShift, blueShift;

/*
 * Other variables used for the Png
 * encoding.
 */

png_byte    color_type;
png_structp png_ptr;
png_infop   info_ptr;
png_colorp  palette;
static char *pngCompBuf;
static int  pngDataLen;
static char *pngBeforeBuf = NULL;

/*
 * Allocate data for the compressed image.
 * We need to ensure that there is enough
 * space to include the palette and the
 * header.
 */

#define PNG_DEST_SIZE(width, height) ((width) * 3 * (height) + 1024 + 256)

/*
 * Just for debug purposes.
 */

#ifdef DEBUG

static int  pngId;
static char pngName[10];
static FILE *pngFile;

#endif

int PngCompareColorTable(NXColorTable *c1, NXColorTable *c2)
{
  return (c1 -> pixel - c2 -> pixel);
}

#define NB_COLOR_MAX 256

int NXCreatePalette32(XImage *src_image, NXColorTable *color_table, CARD8 *image_index, int nb_max)
{
  int    x, y, t, p;
  CARD8 *fbptr;
  CARD32 pixel;

  fbptr = (CARD8 *) (src_image -> data);

  /*
   * TODO: Find a more intelligent way to
   * estimate the number of colors.
   */

  memset(color_table, 0, nb_max * sizeof(NXColorTable));

  for (x = 0, p = 0; x < src_image -> height; x++)
  {
    for (y = 0; y < src_image -> width; y++)
    {
      if (byteOrder == LSBFirst)
      {
        pixel = (CARD32) *(fbptr + 3);
        pixel = (pixel << 8) | (CARD32) *(fbptr + 2);
        pixel = (pixel << 8) | (CARD32) *(fbptr + 1);
        pixel = (pixel << 8) | (CARD32) *fbptr;
      }
      else
      {
        pixel = (CARD32) *fbptr;
        pixel = (pixel << 8) | (CARD32) *(fbptr + 1);
        pixel = (pixel << 8) | (CARD32) *(fbptr + 2);
        pixel = (pixel << 8) | (CARD32) *(fbptr + 3);
      }

      fbptr += 4;

      for (t = 0; t < nb_max; t++)
      {
        if (color_table[t].found == 0)
        {
          color_table[t].pixel =  pixel;
          color_table[t].found =  1;
          p++;
          image_index[((x * src_image -> width) + y)] = t;

          break;
        }
        else if ((CARD32)(color_table[t].pixel) == pixel)
        {
          image_index[((x * src_image -> width) + y)] = t;

          break;
        }
      }

      if (p == nb_max)
      {
        return nb_max + 1;
      }
    }
  }
  return p;
}

int NXCreatePalette16(XImage *src_image, NXColorTable *color_table, CARD8 *image_index, int nb_max)
{
  int    x, y, t, p;
  CARD8 *fbptr;
  CARD16 pixel;

  fbptr = (CARD8 *) (src_image -> data);

  /*
   * TODO: Find a more intelligent way to
   * estimate the number of colors.
   */

  memset(color_table, 0, nb_max * sizeof(NXColorTable));

  for (x = 0, p = 0; x < src_image -> height; x++)
  {
    for (y = 0; y < src_image -> width; y++)
    {
      if (byteOrder == LSBFirst)
      {
        pixel = (CARD16) *(fbptr + 1);
        pixel = (pixel << 8) | (CARD16) *fbptr;
      }
      else
      {
        pixel = (CARD16) *fbptr;
        pixel = (pixel << 8) | (CARD16) *(fbptr + 1);
      }

      fbptr += 2;

      for (t = 0; t < nb_max; t++)
      {
        if (color_table[t].found == 0)
        {
          color_table[t].pixel =  pixel;
          color_table[t].found =  1;
          p++;
          image_index[((x * src_image -> width) + y)] = t;

          break;
        }
        else if ((color_table[t].pixel) == pixel)
        {
          image_index[((x * src_image -> width) + y)] = t;

          break;
        }
      }

      /*
       * In case the number of 16bit words is not even
       * we have 2 padding bytes that we have to skip.
       */

      if ((y == src_image -> width - 1) && (src_image -> width % 2 == 1)) fbptr += 2;

      if (p == nb_max)
      {
        return nb_max + 1;
      }
    }
  }

  return p;
}

char *PngCompressData(XImage *image, int *compressed_size)
{
  unsigned int num = 0;
  CARD8        *srcBuf;

  int dy, w, h;

  int nb_colors;

  NXColorTable color_table[NB_COLOR_MAX];
  CARD8       *image_index;

  image_index = (CARD8 *) malloc((image -> height) * (image -> width) * sizeof(CARD8));

  /*
   * TODO: Be sure the padded bytes are cleaned.
   * It would be better to set to zero the bytes
   * that are not alligned to the word boundary
   * at the end of the procedure.
   */

  memset(image_index, 0, (image -> height) * (image -> width) * sizeof(CARD8));

  *compressed_size = 0;

  pngDataLen = 0;

  /*
   * Initialize the image stuff.
   */

  bitsPerPixel = image -> bits_per_pixel;
  bytesPerLine = image -> bytes_per_line;
  byteOrder = image -> byte_order;

  if (bitsPerPixel < 15)
  {
    #ifdef PANIC
    fprintf(stderr, "******PngCompressData: PANIC! Can't compress images with [%d] bits per pixel.\n",
                bitsPerPixel);
    #endif

    return NULL;
  }

  redShift   = FindLSB(image -> red_mask)   - 1;
  greenShift = FindLSB(image -> green_mask) - 1;
  blueShift  = FindLSB(image -> blue_mask)  - 1;

  redMax   = image -> red_mask   >> redShift;
  greenMax = image -> green_mask >> greenShift;
  blueMax  = image -> blue_mask  >> blueShift;

  w             = image -> width;
  h             = image -> height;
  pngBeforeBuf  = image -> data;

  #ifdef DEBUG
  fprintf(stderr, "******PngCompressData: Compressing image with width [%d] height [%d].\n",
              w, h );
  #endif

  /*
   * Initialize the PNG stuff.
   */

  png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

  if (png_ptr == NULL)
  {
    #ifdef PANIC
    fprintf(stderr, "******PngCompressData: PANIC! Failed creating the png_create_write_struct.\n");
    #endif

    return NULL;
  }

  info_ptr = png_create_info_struct(png_ptr);

  if (info_ptr == NULL)
  {
    #ifdef PANIC
    fprintf(stderr, "******PngCompressData: PANIC! Failed creating the png_create_info_struct.\n");
    #endif

    png_destroy_write_struct(&png_ptr, NULL);

    return NULL;
  }

  if (setjmp(png_jmpbuf(png_ptr)))
  {
    #ifdef PANIC
    fprintf(stderr, "******PngCompressData: PANIC! Error during compression initialization.\n");
    #endif

    png_destroy_write_struct(&png_ptr, &info_ptr);

    return NULL;
  }

  /*
   * Be sure we allocate enough data.
   */

  #ifdef TEST
  fprintf(stderr, "******PngCompressData: Allocating [%d] bytes for the destination data.\n",
              PNG_DEST_SIZE(w, h));
  #endif

  pngCompBuf = malloc(PNG_DEST_SIZE(w, h));

  if (pngCompBuf == NULL)
  {
    #ifdef PANIC
    fprintf(stderr, "******PngCompressData: PANIC! Error allocating [%d] bytes for the Png data.\n",
                PNG_DEST_SIZE(w, h));
    #endif

    return NULL;
  }

  png_set_write_fn(png_ptr, (void *) pngCompBuf, PngWriteData, PngFlushData);

  if (setjmp(png_jmpbuf(png_ptr)))
  {
    #ifdef PANIC
    fprintf(stderr, "******PngCompressData: PANIC! Error writing the header.\n");
    #endif

    png_destroy_write_struct(&png_ptr, &info_ptr);

    free(pngCompBuf);

    return NULL;
  }

  png_set_compression_level(png_ptr, PNG_Z_LEVEL);

  if (bitsPerPixel == 16)
  {
    nb_colors = NXCreatePalette16(image, color_table, image_index, NB_COLOR_MAX);
  }
  else
  {
    nb_colors = NXCreatePalette32(image, color_table, image_index, NB_COLOR_MAX);
  }

  if (nb_colors <= NB_COLOR_MAX)
  {
    color_type = PNG_COLOR_TYPE_PALETTE;
  }
  else
  {
    color_type = PNG_COLOR_TYPE_RGB;
  }

  png_set_IHDR(png_ptr, info_ptr, w, h,
                   8, color_type, PNG_INTERLACE_NONE,
                       PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);

  if (color_type == PNG_COLOR_TYPE_PALETTE)
  {
    palette = png_malloc(png_ptr, sizeof(*palette) * 256);

    /*
     * TODO: Do we need to clean these bytes?
     *
     * memset(palette, 0, sizeof(*palette) * 256);
     */

    for (num = 0; num < 256 && color_table[num].found != 0; num++)
    {
      if (bitsPerPixel == 24)
      {
        palette[num].red = (color_table[num].pixel >> redShift) & redMax;
        palette[num].green = (color_table[num].pixel >> greenShift) & greenMax;
        palette[num].blue = color_table[num].pixel >> blueShift & blueMax;
      }
      else
      {
        int inRed, inGreen, inBlue;

        inRed = (color_table[num].pixel >> redShift) & redMax;
        inGreen = (color_table[num].pixel >> greenShift) & greenMax;
        inBlue = color_table[num].pixel >> blueShift & blueMax;

        palette[num].red = (CARD8)((inRed * 255 + redMax / 2) / redMax);
        palette[num].green = (CARD8)((inGreen * 255 + greenMax / 2) / greenMax);
        palette[num].blue = (CARD8)((inBlue * 255 + blueMax / 2) / blueMax);
      }

      #ifdef DEBUG
      fprintf(stderr, "******PngCompressData: pixel[%d] r[%d] g[%d] b[%d].\n",
                  (int) color_table[num].pixel,palette[num].red,palette[num].green,palette[num].blue);
      #endif
    }

    png_set_PLTE(png_ptr, info_ptr, palette, num);

    #ifdef DEBUG
    fprintf(stderr, "******PngCompressedData: Setting palette.\n");
    #endif
  }

  /*
   * End of palette.
   */

  png_write_info(png_ptr, info_ptr);

  /*
   * Allocate space for one line of
   * the image, 3 bytes per pixel.
   */

  #ifdef DEBUG
  fprintf(stderr, "******PngCompressedData: Initialization finished.\n");
  #endif

  if (setjmp(png_jmpbuf(png_ptr)))
  {
    #ifdef PANIC
    fprintf(stderr, "******PngCompressData: PANIC! Error while writing the image rows.\n");
    #endif

    png_destroy_write_struct(&png_ptr, &info_ptr);

    free(pngCompBuf);

    return NULL;
  }

  if (color_type == PNG_COLOR_TYPE_PALETTE)
  {
    srcBuf = (CARD8 *) malloc(w * sizeof(CARD8));

    if (srcBuf == NULL)
    {
      #ifdef PANIC
      fprintf(stderr, "******PngCompressData: PANIC! Cannot allocate [%d] bytes.\n",
                  (int) (w * sizeof(CARD8)));
      #endif

      return NULL;
    }

    /*
     * TODO: Be sure the padded bytes are cleaned.
     * It would be better to set to zero the bytes
     * that are not alligned to the word boundary
     * at the end of the procedure.
     */

    memset(srcBuf, 0, w * sizeof(CARD8));
  }
  else
  {
    srcBuf = (CARD8 *) malloc(w * 3 * sizeof(CARD8));

    /*
     * TODO: See above.
     */

    memset(srcBuf, 0, w * 3 * sizeof(CARD8));
  }

  if (srcBuf == NULL)
  {
    #ifdef PANIC
    fprintf(stderr, "******PngCompressData: PANIC! Cannot allocate [%d] bytes.\n",
                w * 3);
    #endif

    free(pngCompBuf);

    return NULL;
  }

  for (dy = 0; dy < h; dy++)
  {
    if (color_type == PNG_COLOR_TYPE_RGB)
    {
      PrepareRowForPng(srcBuf, dy, w);
    }
    else
    {
      memcpy(srcBuf, image_index + (dy * w), w);
    }

    png_write_row(png_ptr, srcBuf);
  }

  #ifdef DEBUG
  fprintf(stderr, "******PngCompressedData: Compression finished. Lines handled [%d,%d].\n",
              dy, h);
  #endif

  free(srcBuf);
  free(image_index);

  if (setjmp(png_jmpbuf(png_ptr)))
  {
    #ifdef PANIC
    fprintf(stderr, "******PngCompressData: PANIC! error during end of write.\n");
    #endif

    png_destroy_write_struct(&png_ptr, &info_ptr);

    free(pngCompBuf);

    return NULL;
  }

  png_write_end(png_ptr, NULL);

  if (color_type == PNG_COLOR_TYPE_PALETTE)
  {
    png_free(png_ptr, palette);
  }

  png_destroy_write_struct(&png_ptr, &info_ptr);

  /*
   * Check the size of the resulting data.
   */

  if (pngDataLen > 0)
  {
    #ifdef DEBUG

    int i = 0;

    fprintf(stderr, "******PngCompressedData: Compressed size [%d].\n",
                pngDataLen);

    pngId++;
    sprintf(pngName, "png%d", pngId);
    pngFile = fopen(pngName, "w");

    for (i = 0; i < pngDataLen; i++)
    {
      fprintf(pngFile, "%c", *(pngCompBuf + i));
    }

    fclose(pngFile);

    #endif

    *compressed_size = pngDataLen;

    return pngCompBuf;
  }
  else
  {
    #ifdef DEBUG
    fprintf(stderr, "******PngCompressedData: PANIC! Invalid size of the compressed data [%d].\n",
                pngDataLen);
    #endif

    free(pngCompBuf);

    return NULL;
  }
}

static void PngWriteData(png_structp png_ptr, png_bytep data, png_size_t length)
{
  memcpy(((char *) png_get_io_ptr(png_ptr) + pngDataLen), data, length);

  pngDataLen += length;
}

static void PngFlushData(png_structp png_ptr)
{
}

void PrepareRowForPng(CARD8 *dst, int y, int count)
{
  if (bitsPerPixel == 32)
  {
    if (redMax == 0xff &&
           greenMax == 0xff &&
               blueMax == 0xff)
    {
      PrepareRowForPng24(dst, y, count);
    }
    else
    {
      PrepareRowForPng32(dst, y, count);
    }
  }
  else if (bitsPerPixel == 24)
  {
    memcpy(dst, pngBeforeBuf + y * bytesPerLine, count * 3);
  }
  else
  {
    /*
     * 16 bpp assumed.
     */

    PrepareRowForPng16(dst, y, count);
  }
}



void PrepareRowForPng24(CARD8 *dst, int y, int count)
{
  CARD8 *fbptr;
  CARD32 pix;

  fbptr = (CARD8 *) (pngBeforeBuf + y * bytesPerLine);

  while (count--)
  {
    if (byteOrder == LSBFirst)
    {
      pix = (CARD32) *(fbptr + 2);
      pix = (pix << 8) | (CARD32) *(fbptr+1);
      pix = (pix << 8) | (CARD32) *fbptr;
    }
    else
    {
      pix = (CARD32) *(fbptr + 1);
      pix = (pix << 8) | (CARD32) *(fbptr + 2);
      pix = (pix << 8) | (CARD32) *(fbptr + 3);
    }

    *dst++ = (CARD8)(pix >> redShift);
    *dst++ = (CARD8)(pix >> greenShift);
    *dst++ = (CARD8)(pix >> blueShift);

    fbptr+=4;
  }
}

#define DEFINE_PNG_GET_ROW_FUNCTION(bpp)                                    \
                                                                            \
void PrepareRowForPng##bpp(CARD8 *dst, int y, int count)                    \
{                                                                           \
  CARD8 *fbptr;                                                             \
  CARD##bpp pix;                                                            \
  int inRed, inGreen, inBlue;                                               \
  int i;                                                                    \
                                                                            \
  fbptr = (CARD8 *) (pngBeforeBuf + y * bytesPerLine);                      \
                                                                            \
  while (count--)                                                           \
  {                                                                         \
    pix = 0;                                                                \
                                                                            \
    if (byteOrder == LSBFirst)                                              \
    {                                                                       \
      for (i = (bpp >> 3) - 1; i >= 0; i--)                                 \
      {                                                                     \
        pix = (pix << 8) | (CARD32) *(fbptr + i);                           \
      }                                                                     \
    }                                                                       \
    else                                                                    \
    {                                                                       \
      for (i = 0; i < (bpp >> 3); i++)                                      \
      {                                                                     \
        pix = (pix << 8) | (CARD32) *(fbptr + i);                           \
      }                                                                     \
    }                                                                       \
                                                                            \
    fbptr += (bpp >> 3);                                                    \
                                                                            \
    inRed = (int)                                                           \
            (pix >> redShift   & redMax);                                   \
    inGreen = (int)                                                         \
            (pix >> greenShift & greenMax);                                 \
    inBlue  = (int)                                                         \
            (pix >> blueShift  & blueMax);                                  \
    *dst++ = (CARD8)((inRed   * 255 + redMax / 2) /                         \
                         redMax);                                           \
    *dst++ = (CARD8)((inGreen * 255 + greenMax / 2) /                       \
                         greenMax);                                         \
    *dst++ = (CARD8)((inBlue  * 255 + blueMax / 2) /                        \
                         blueMax);                                          \
  }                                                                         \
}

DEFINE_PNG_GET_ROW_FUNCTION(16)
DEFINE_PNG_GET_ROW_FUNCTION(32)