#include <stdio.h></stdio.h>

#include <stdlib.h></stdlib.h>

#include <string.h></string.h>

#include "tiio_tzp.h"

extern "C" {

#include "../tif/tifimage/tiff.h"

#include "../tif/tifimage/tiffio.h"

}

//#include "toonz.h"

//#include "tmsg.h"

//#include "file.h"

//#include "img.h"

//#include "tiff.h"

//#include "tiffio.h"

//#include "tim.h"

//#include "history.h"

//#include "../infoRegionP.h"

//#include "version.h"

//#include "machine.h"

//#include "tenv.h"

//#include "ImageP/img_security.h"

#define ICON_WIDTH 100

#define ICON_HEIGHT 90

#define TBOOL int

#define FALSE 0

#define TRUE 1

#define UCHAR unsigned char

#define USHORT unsigned short

#define ULONG unsigned long

#define UINT unsigned int

#define CASE                                                                   \

  break;                                                                       \

  case

#define __OR case

#define DEFAULT                                                                \

  break;                                                                       \

  default

#ifndef MAXINT

#define MAXINT ((int)((~0U) >> 1))

#endif

#define NOT_LESS_THAN(A, B)

typedef struct { UCHAR r, g, b, m; } LPIXEL;

#define TMALLOC(A, C) A = malloc(C * sizeof(A[0]));

#define TFREE(A) free(A);

#define NIL 0

typedef struct {

  int x1, y1, x2, y2;

  int x_offset, y_offset;         /*  offset all'interno della regione   */

  int xsize, ysize;               /*      dimensioni della regione       */

  int scanNrow, scanNcol;         /* righe e col. dell'immagine da scan. */

  int startScanRow, startScanCol; /*   offset nell'immagine da scandire  */

  int step;                       /*          fattore di scale           */

  int lx_in, ly_in;               /*    dimensioni immag. da scandire    */

  int verso_x, verso_y;           /* verso di scrittura nel buffer dest. */

  int buf_inc;                    /* incremento tra due pix. consecutivi */

  int sxpix, expix, sypix, eypix; /* pixel estremi del buffer di input   */

} INFO_REGION;

typedef struct {

  /*UCHAR    tone_offs; sempre 0 */

  UCHAR tone_bits;

  UCHAR color_offs;

  UCHAR color_bits;

  UCHAR pencil_offs;

  UCHAR pencil_bits;

  USHORT offset_mask;  // fa allo stesso tempo sia da offset che da maschera

  USHORT default_val;  // da utilizzare, p.es., per pixel fuori dall'immagine

  short n_tones;

  short n_colors;

  short n_pencils;

} TCM_INFO;

static const TCM_INFO Tcm_old_default_info = {

    /*0,*/ 4, 4, 5, 9, 2, 0x0800, 0x080f, 16, 32, 4};

static const TCM_INFO Tcm_new_default_info = {

    /*0,*/ 4, 4, 7, 11, 5, 0x0000, 0x000f, 16, 128, 32};

static const TCM_INFO Tcm_24_default_info = {

    /*0,*/ 8, 8, 8, 16, 8, 0x0000, 0x00ff, 256, 256, 256};

#define TCM_TONE_MASK(TCM) ((1U << (TCM).tone_bits) - 1U)

#define TCM_COLOR_MASK(TCM)                                                    \

  (((1U << (TCM).color_bits) - 1U) << (TCM).color_offs)

#define TCM_PENCIL_MASK(TCM)                                                   \

  (((1U << (TCM).pencil_bits) - 1U) << (TCM).pencil_offs)

#define TCM_COLOR_INDEX(TCM, ID)                                               \

  ((ID) << (TCM).color_offs | ((TCM).n_tones - 1) | (TCM).offset_mask)

#define TCM_PENCIL_INDEX(TCM, ID)                                              \

  ((ID) << (TCM).pencil_offs | (TCM).offset_mask)

#define TCM_INDEX_IS_COLOR_ONLY(TCM, INDEX)                                    \

  (((INDEX)&TCM_TONE_MASK(TCM)) == TCM_TONE_MASK(TCM))

#define TCM_INDEX_IS_PENCIL_ONLY(TCM, INDEX) (((INDEX)&TCM_TONE_MASK(TCM)) == 0)

#define TCM_COLOR_ID(TCM, INDEX)                                               \

  ((int)(((INDEX) >> (TCM).color_offs) & ((1U << (TCM).color_bits) - 1U)))

#define TCM_PENCIL_ID(TCM, INDEX)                                              \

  ((int)(((INDEX) >> (TCM).pencil_offs) & ((1U << (TCM).pencil_bits) - 1U)))

#define TCM_MIN_CMAP_BUFFER_SIZE(TCM)                                          \

  ((((TCM).n_pencils - 1) << (TCM).pencil_offs |                               \

    ((TCM).n_colors - 1) << (TCM).color_offs | (TCM).n_tones - 1) +            \

   1)

#define TCM_MIN_CMAP_COLBUFFER_SIZE(TCM) ((TCM).n_colors * (TCM).n_tones)

#define TCM_MIN_CMAP_PENBUFFER_SIZE(TCM) ((TCM).n_pencils * (TCM).n_tones)

#define TCM_CMAP_BUFFER_SIZE(TCM)                                              \

  (1 << ((TCM).pencil_bits + (TCM).color_bits + (TCM).tone_bits))

#define TCM_CMAP_COLBUFFER_SIZE(TCM) (1 << ((TCM).color_bits + (TCM).tone_bits))

#define TCM_CMAP_PENBUFFER_SIZE(TCM)                                           \

  (1 << ((TCM).pencil_bits + (TCM).tone_bits))

static int Next_img_read_with_extra = FALSE;

static int Read_with_extra          = FALSE;

#define SET_READ_WITH_EXTRA                                                    \

  {                                                                            \

    Read_with_extra          = Next_img_read_with_extra;                       \

    Next_img_read_with_extra = FALSE;                                          \

  }

typedef struct {

  USHORT bits_per_sample, samples_per_pixel, photometric;

  int xsize, ysize, xSBsize, ySBsize, x0, y0;

  double x_dpi, y_dpi;

  double h_pos;  // in pixel, mentre TIFFTAG_XPOSITION e' in RESUNITS

  UCHAR extra_mask;

  TBOOL edu_file;

} TZUP_FIELDS;

// Tipi di  IMAGE

enum img_type {

  IMG_NONE,

  CMAPPED,   /* fa riferimento a una color-map */

  CMAPPED24, /* 3 x 8 bit (ink, paint, ramp) + 8 bit extra (nel MSB) */

  RGB,       /* ogni pixel e' una terna red-green-blue   - 8bit per canale */

  RGB64,     /* ogni pixel e' una terna red-green-blue - 16bit per canale */

  GR8,       /* a toni di grigio */

  CMAP       /* color map */

};

/* pixel-map */

struct s_pixmap {

  USHORT *buffer;

  UCHAR *extra;     /* patches etc. */

  UCHAR extra_mask; /* bits extra usati in buffer (CMAPPED24) o in extra */

  int xsize, ysize;

  int xSBsize, ySBsize, xD, yD; /* savebox */

  double x_dpi, y_dpi;

  double h_pos; /* in pixel */

};

/* color-map */

struct s_cmap {

  char *name;        /* riferimento a CMAP esterna */

  LPIXEL *buffer;    /* buffer della colormap (premoltiplicata) */

  LPIXEL *penbuffer; /* buffer della componente di pencil per > 16 bits */

  LPIXEL *colbuffer; /* buffer della componente di color  per > 16 bits */

  LPIXEL *pencil;    /* i colori non premoltiplicati */

  LPIXEL *color;     /* tanti quanto dicono info.n_pencils e n_colors */

  TCM_INFO info;     /* vedi tcm.h */

  void *names;       /* nomi dei colori, gestiti da colorsdb */

  /* seguono i campi che andrebbero eliminati perche' doppioni */

  int offset;            /* == info.offset_mask */

  int pencil_n, color_n; /* == info.n_pencils e n_colors */

};

/* Enum per l'identificazione dell' algoritmo di riduzione dei colori */

typedef enum { CM_NONE = -1, CM_STANDARD, CM_CUSTOM } IMG_CM_ALGORITHM;

/* Struttura per le modalita' di scrittura dei formati di file supportati  */

typedef struct {

  char rgb_is_compressed;

  char rgb_write_matte;

  char rgb_64_bits;

  char rgb_colorstyle; /* full color or greyscale */

  char tga_bytes_per_pixel;

  char tga_is_colormap;

  char tga_is_compressed;

  /*

* Microsoft Windows Bitmap (BMP and DIB)

*

*                         | compression | colorstyle | numcolors |

* ---------------------------------------------------------------

*       BLack & White     |      0      |     0      |     2     |

* ----------------------------------------------------------------

*    16 Grey Tones        |      0      |    GR8     |     16    |

* ---------------------------------------------------------------

*    16 Grey Tones Comp.  |      1      |    GR8     |     16    |

* ---------------------------------------------------------------

*   256 Grey Tones        |      0      |    GR8     |     256   |

* ---------------------------------------------------------------

*   256 Grey Tones Comp.  |      1      |    GR8     |     256   |

* ---------------------------------------------------------------

*    16 Color Mapped      |      0      |  CMAPPED   |     16    |

* ---------------------------------------------------------------

*    16 Color Mapped Comp.|      1      |  CMAPPED   |     16    |

* ---------------------------------------------------------------

*   256 Color Mapped      |      0      |  CMAPPED   |     256   |

* ---------------------------------------------------------------

*   256 Color Mapped Comp.|      1      |  CMAPPED   |     256   |

* ---------------------------------------------------------------

*       Full Color        |      0      |    RGB     |     0     |

* ---------------------------------------------------------------

*

*/

  unsigned short bmp_compression;

  unsigned short bmp_colorstyle;

  unsigned short bmp_numcolors;

  /*---------------------------------------------------------------*/

  unsigned int jpg_quality;

  unsigned int jpg_smoothing;

  unsigned int jpg_components;

  /*---------------------------------------------------------------*/

  unsigned short tif_compression;

  unsigned short tif_orientation;

  unsigned short tif_photometric;

  unsigned short tif_bits_per_sample;

  unsigned short tif_samples_per_pixel;

  /*---------------------------------------------------------------*/

  IMG_CM_ALGORITHM cm_algorithm;

  /*---------------------------------------------------------------*/

  /*TNZMOVIE_QUALITY      pct_quality;

TNZMOVIE_COMPRESSION  pct_compression;

*/

  /*---------------------------------------------------------------*/

  /*

TNZMOVIE_QUALITY     mov_quality;

TNZMOVIE_COMPRESSION mov_compression;

*/

  int avi_bpp;

  char *avi_compression;

} IMG_IO_SETTINGS;

/* Struttura IMAGE */

typedef struct s_image {

  enum img_type type;

  char *filename;

  char *history;

  struct s_pixmap icon;   /* Icon */

  struct s_cmap cmap;     /* Colormap */

  struct s_pixmap pixmap; /* Pixel Map */

  IMG_IO_SETTINGS io_settings;

} IMAGE;

extern int Silent_tiff_print_error;

extern int Tiff_ignore_missing_internal_colormap;

static int write_rgb_image(IMAGE *image, TIFF *tif),

    write_cmapped_image(IMAGE *image, TIFF *tif),

    write_cmapped24_image(IMAGE *image, TIFF *tif),

    write_extra(IMAGE *image, TIFF *tif),

    get_tzup_fields(TIFF *tif, TZUP_FIELDS *tzup_f),

    get_bits_per_sample(TIFF *tif, USHORT *bps),

    get_samples_per_pixel(TIFF *tif, USHORT *spp),

    get_image_sizes(TIFF *tif, int *xsize, int *ysize),

    get_photometric(TIFF *tif, USHORT *pm),

    get_resolutions(TIFF *tif, double *x_dpi, double *y_dpi),

    get_history(TIFF *tif, char **history),

    get_compression(TIFF *tif, int *compression),

    get_rows_per_strip(TIFF *tif, long *rowperstrip),

    get_tag_software(TIFF *tif, char *tag_software),

    get_orientation(TIFF *tif, int *orientation);

static bool scanline_needs_swapping(TIFF *tfp);

static void get_planarconfig(TIFF *tif, USHORT *planargonfig);

static void get_image_offsets_and_dimensions(TIFF *tif, int xSBsize,

                                             int ySBsize, int *x0, int *y0,

                                             int *xsize, int *ysize,

                                             double *h_pos, UCHAR *extra_mask,

                                             TBOOL *edu_file),

    get_plt_name(char *filename, char *pltname),

    clear_image_buffer_16(IMAGE *img, USHORT bg_val),

    clear_image_buffer_24(IMAGE *img, ULONG bg_val),

    clear_extra(IMAGE *img, UCHAR bg_val),

    clear_image_region_buffer_16(USHORT *buffer, int x0, int y0,

                                 int clear_xsize, int clear_ysize, int wrap_x,

                                 USHORT bg_val),

    clear_image_region_buffer_24(ULONG *buffer, int x0, int y0, int clear_xsize,

                                 int clear_ysize, int wrap_x, ULONG bg_val),

    clear_extra_region(UCHAR *extra, int x0, int y0, int clear_xsize,

                       int clear_ysize, int wrap_x, UCHAR bg_val);

static int get_image(TIFF *tif, IMAGE *image),

    get_image_contig_16(TIFF *tif, IMAGE *image),

    get_image_contig_24(TIFF *tif, IMAGE *image),

    get_icon(TIFF *tif, IMAGE *image), get_extra(TIFF *tif, IMAGE *image);

static char Verbose = 0; /* Variabile per debug */

/*---------------------------------------------------------------------------*/

static UINT get_output_compression(void) {

  static UINT output_compression = 0;

  /*

char *s;

if ( !output_compression)

{

if (tenv_get_var_s("TOONZ_TZUP_COMPRESSION", &s))

{

if (strstr (s, "rle") || strstr (s, "RLE"))

output_compression = COMPRESSION_TOONZ1;

else

output_compression = COMPRESSION_LZW;

}

else

output_compression = COMPRESSION_LZW;

}

*/

  return output_compression;

}

/*---------------------------------------------------------------------------*/

#ifdef CICCIO

int img_write_tzup(unsigned short *filename, IMAGE *image) {

  TIFF *tfp;

  int bits_per_sample, samples_per_pixel, photometric, planar_config;

  int orientation, rows_per_strip, bytes_per_line;

  int width, height, row, scanline, cmap_size, i;

  char str[200], *history;

  UCHAR *outbuf;

  USHORT window[TOONZWINDOW_COUNT];

  USHORT palette[TOONZPALETTE_COUNT];

  TCM_INFO *tcm;

  UINT tif_compression;

  /* CHECK_IMAGEDLL_LICENSE_AND_GET_IMG_LICENSE_ATTR */

  Silent_tiff_print_error               = 1;

  Tiff_ignore_missing_internal_colormap = 1;

  tfp                                   = TIFFOpen(filename, "w");

  if (!tfp) {

    /*throw "unable to open file for output"; , filename);*/

    return FALSE;

  }

  switch (image->type) {

    CASE RGB : bits_per_sample       = 8;

    samples_per_pixel                = 4;

    photometric                      = PHOTOMETRIC_RGB;

    planar_config                    = PLANARCONFIG_CONTIG;

    CASE CMAPPED : bits_per_sample   = 16;

    samples_per_pixel                = 1;

    photometric                      = PHOTOMETRIC_PALETTE;

    planar_config                    = PLANARCONFIG_CONTIG;

    CASE CMAPPED24 : bits_per_sample = 32;

    samples_per_pixel                = 1;

    photometric                      = PHOTOMETRIC_PALETTE;

    planar_config                    = PLANARCONFIG_CONTIG;

  DEFAULT:

    /*tmsg_error("bad image type writing file %s", filename);*/

    goto bad;

  }

  orientation = ORIENTATION_BOTLEFT;

  /*

width  = image->pixmap.xsize;

height = image->pixmap.ysize;

*/

  width  = image->pixmap.xSBsize;

  height = image->pixmap.ySBsize;

  if (image->cmap.info.n_pencils && image->cmap.info.n_colors)

    tcm = &image->cmap.info;

  else if (image->type == CMAPPED24)

    tcm = (TCM_INFO *)&Tcm_24_default_info;

  else

    tcm = (TCM_INFO *)&Tcm_new_default_info;

  if (image->cmap.offset)

    cmap_size = TCM_MIN_CMAP_BUFFER_SIZE(*tcm);

  else

    cmap_size = TCM_CMAP_BUFFER_SIZE(*tcm);

  palette[0]  = (image->cmap.offset > 0) ? 4 : 3;

  palette[1]  = image->cmap.offset;

  palette[2]  = cmap_size <= 0xffff ? cmap_size : 0;

  palette[3]  = 0 /* tcm->tone_offs */;

  palette[4]  = tcm->tone_bits;

  palette[5]  = tcm->color_offs;

  palette[6]  = tcm->color_bits;

  palette[7]  = tcm->pencil_offs;

  palette[8]  = tcm->pencil_bits;

  palette[9]  = tcm->offset_mask;

  palette[10] = tcm->n_colors;

  palette[11] = tcm->n_pencils;

  for (i = 12; i < TOONZPALETTE_COUNT; i++) palette[i] = 0;

  tif_compression = get_output_compression();

  TIFFSetField(tfp, TIFFTAG_TOONZPALETTE, palette);

  TIFFSetField(tfp, TIFFTAG_BITSPERSAMPLE, bits_per_sample);

  TIFFSetField(tfp, TIFFTAG_SAMPLESPERPIXEL, samples_per_pixel);

  TIFFSetField(tfp, TIFFTAG_IMAGEWIDTH, width);

  TIFFSetField(tfp, TIFFTAG_IMAGELENGTH, height);

  TIFFSetField(tfp, TIFFTAG_ORIENTATION, orientation);

  TIFFSetField(tfp, TIFFTAG_PLANARCONFIG, planar_config);

  TIFFSetField(tfp, TIFFTAG_PHOTOMETRIC, photometric);

  TIFFSetField(tfp, TIFFTAG_COMPRESSION, tif_compression);

  /*

* NOTARE CHE VA COMPLETATA LA PARTE RELAITVA AL SETTAGGIO DELLA RISOLUZIONE

*

*/

  TIFFSetField(tfp, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);

  TIFFSetField(tfp, TIFFTAG_XRESOLUTION, image->pixmap.x_dpi);

  TIFFSetField(tfp, TIFFTAG_YRESOLUTION, image->pixmap.y_dpi);

  switch (orientation) {

    CASE ORIENTATION_BOTLEFT

        : __OR ORIENTATION_BOTRIGHT

          : __OR ORIENTATION_TOPLEFT

            : __OR ORIENTATION_TOPRIGHT

              : if (image->pixmap.x_dpi) TIFFSetField(

                    tfp, TIFFTAG_XPOSITION,

                    image->pixmap.h_pos / image->pixmap.x_dpi + 8.0);

    CASE ORIENTATION_LEFTBOT

        : __OR ORIENTATION_RIGHTBOT

          : __OR ORIENTATION_LEFTTOP

            : __OR ORIENTATION_RIGHTTOP

              : if (image->pixmap.y_dpi) TIFFSetField(

                    tfp, TIFFTAG_XPOSITION,

                    image->pixmap.h_pos / image->pixmap.y_dpi + 8.0);

  }

  /*sprintf(str, "TOONZ %s", versione_del_software);*/

  TIFFSetField(tfp, TIFFTAG_SOFTWARE, str);

  /* Aggiungo le informazioni relative alla savebox a all'history */

  window[0] = image->pixmap.xD;

  window[1] = image->pixmap.yD;

  window[2] = image->pixmap.xsize;

  window[3] = image->pixmap.ysize;

  window[4] = image->pixmap.extra_mask;

  for (i = 5; i < TOONZWINDOW_COUNT - 1; i++) window[i] = 0;

  window[TOONZWINDOW_COUNT - 1] = 0;

  /*  (Img_license_attr & TA_TOONZ_EDU) != 0;*/

  TIFFSetField(tfp, TIFFTAG_TOONZWINDOW, window);

  history = build_history();

  /*

if (image->history)

{

switch(check_history(image->history, history))

{

CASE APPEND:

image->history = append_history(image->history, history);

CASE REPLACE:

image->history = replace_last_history(image->history, history);

DEFAULT:

tmsg_error("Internal error: bad history type");

abort();

}

free (history);

}

else

*/

  image->history = history;

  TIFFSetField(tfp, TIFFTAG_TOONZHISTORY, image->history);

  bytes_per_line = TIFFScanlineSize(tfp);

  /*

* massima lunghezza di bytes in una strip e' 8k

* vedi Graphics File Formats pag.48

*/

  if (planar_config == PLANARCONFIG_CONTIG)

    rows_per_strip = (8 * 1024) / bytes_per_line;

  else

    rows_per_strip = 1L;

  TIFFSetField(tfp, TIFFTAG_ROWSPERSTRIP,

               rows_per_strip == 0 ? 1L : rows_per_strip);

  switch (image->type) {

    CASE RGB : if (!write_rgb_image(image, tfp)) {

      // tmsg_error("unable to write buffer to file %s", filename);

      goto bad;

    }

    CASE CMAPPED : if (!write_cmapped_image(image, tfp)) {

      // tmsg_error("unable to write buffer to file %s", filename);

      goto bad;

    }

    CASE CMAPPED24 : if (!write_cmapped24_image(image, tfp)) {

      // tmsg_error("unable to write buffer to file %s", filename);

      goto bad;

    }

  DEFAULT:

    // tmsg_error("bad image type writing file %s", filename);

    goto bad;

  }

  Silent_tiff_print_error               = 0;

  Tiff_ignore_missing_internal_colormap = 0;

  TIFFClose(tfp);

  return TRUE;

bad:

  Silent_tiff_print_error               = 0;

  Tiff_ignore_missing_internal_colormap = 0;

  TIFFClose(tfp);

  return FALSE;

}

#endif

/*---------------------------------------------------------------------------*/

static int write_rgb_image(IMAGE *image, TIFF *tfp) {

  int scanlinesize;

  UCHAR *outbuf, *buf;

  int row, lx, ly, x, wrapx, x0, y0;

  LPIXEL *gl_buf, *tmp;

  lx    = image->pixmap.xSBsize;

  ly    = image->pixmap.ySBsize;

  x0    = image->pixmap.xD;

  y0    = image->pixmap.yD;

  wrapx = image->pixmap.xsize;

  tmp          = (LPIXEL *)image->pixmap.buffer + y0 * wrapx + x0;

  scanlinesize = TIFFScanlineSize(tfp);

  outbuf       = new UCHAR[scanlinesize];

  if (!outbuf) return FALSE;

  for (row = 0; row < ly; row++) {

    buf    = outbuf;

    gl_buf = tmp;

    for (x = 0; x < lx; x++) {

      *buf++ = gl_buf->r;

      *buf++ = gl_buf->g;

      *buf++ = gl_buf->b;

      *buf++ = gl_buf->m;

      gl_buf++;

    }

    if (TIFFWriteScanline(tfp, outbuf, row, 0) < 0) goto bad;

    tmp += wrapx;

  }

  delete[] outbuf;

  if (image->pixmap.extra_mask) write_extra(image, tfp);

  return TRUE;

bad:

  // tmsg_error("write_scan_line failed at row %d", row);

  delete[] outbuf;

  return FALSE;

}

/*---------------------------------------------------------------------------*/

static int write_cmapped_image(IMAGE *image, TIFF *tfp) {

  int scanline, lx, ly, x0, y0, wrapx;

  int row;

  UCHAR *outbuf;

  USHORT *tmp;

  int tmp_icon;

  struct s_pixmap ori_icon;

  UINT tif_compression;

  tif_compression = get_output_compression();

  tmp_icon = FALSE;

  lx    = image->pixmap.xSBsize;

  ly    = image->pixmap.ySBsize;

  x0    = image->pixmap.xD;

  y0    = image->pixmap.yD;

  wrapx = image->pixmap.xsize;

  tmp    = image->pixmap.buffer + y0 * wrapx + x0;

  outbuf = 0;

  for (row = 0; row < ly; row++) {

    outbuf = (UCHAR *)tmp;

    if (TIFFWriteScanline(tfp, outbuf, row, 0) < 0) goto bad;

    tmp += wrapx;

  }

  if (image->pixmap.extra_mask && !image->icon.buffer) {

    ori_icon = image->icon;

    // make_icon (image, ICON_WIDTH, ICON_HEIGHT);

    tmp_icon = TRUE;

  }

  if (image->icon.buffer) {

    if (!TIFFFlush(tfp)) {

      // tmsg_error("Unable to flush data to .tz(up) file");

      goto bad;

    }

    lx = image->icon.xsize;

    ly = image->icon.ysize;

    TIFFSetField(tfp, TIFFTAG_SUBFILETYPE, 1);

    TIFFSetField(tfp, TIFFTAG_BITSPERSAMPLE, 16);

    TIFFSetField(tfp, TIFFTAG_SAMPLESPERPIXEL, 1);

    TIFFSetField(tfp, TIFFTAG_IMAGEWIDTH, lx);

    TIFFSetField(tfp, TIFFTAG_IMAGELENGTH, ly);

    TIFFSetField(tfp, TIFFTAG_ORIENTATION, ORIENTATION_BOTLEFT);

    TIFFSetField(tfp, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);

    TIFFSetField(tfp, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_PALETTE);

    TIFFSetField(tfp, TIFFTAG_COMPRESSION, tif_compression);

    scanline = TIFFScanlineSize(tfp);

    outbuf   = (UCHAR *)image->icon.buffer;

    for (row = 0; row < ly; row++) {

      if (TIFFWriteScanline(tfp, outbuf, row, 0) < 0) {

        // tmsg_error("error writing icon to .tz(up) file");

        goto bad;

      }

      outbuf += scanline;

    }

  }

  if (image->pixmap.extra_mask) write_extra(image, tfp);

  if (tmp_icon && image->icon.buffer) {

    TFREE(image->icon.buffer)

    image->icon = ori_icon;

  }

  return TRUE;

bad:

  if (tmp_icon && image->icon.buffer) {

    TFREE(image->icon.buffer)

    image->icon = ori_icon;

  }

  return FALSE;

}

/*---------------------------------------------------------------------------*/

static int write_cmapped24_image(IMAGE *image, TIFF *tfp) {

  int scanline, lx, ly, x0, y0, wrapx;

  int row;

  UCHAR *outbuf;

  ULONG *tmp;

  UINT tif_compression;

  tif_compression = get_output_compression();

  lx    = image->pixmap.xSBsize;

  ly    = image->pixmap.ySBsize;

  x0    = image->pixmap.xD;

  y0    = image->pixmap.yD;

  wrapx = image->pixmap.xsize;

  tmp    = (ULONG *)image->pixmap.buffer + y0 * wrapx + x0;

  outbuf = 0;

  for (row = 0; row < ly; row++) {

    outbuf = (UCHAR *)tmp;

    if (TIFFWriteScanline(tfp, outbuf, row, 0) < 0) goto bad;

    tmp += wrapx;

  }

  if (image->icon.buffer) {

    if (!TIFFFlush(tfp)) {

      // tmsg_error("Unable to flush data to .tz(up) file");

      goto bad;

    }

    lx = image->icon.xsize;

    ly = image->icon.ysize;

    TIFFSetField(tfp, TIFFTAG_SUBFILETYPE, 1);

    TIFFSetField(tfp, TIFFTAG_BITSPERSAMPLE, 32);

    TIFFSetField(tfp, TIFFTAG_SAMPLESPERPIXEL, 1);

    TIFFSetField(tfp, TIFFTAG_IMAGEWIDTH, lx);

    TIFFSetField(tfp, TIFFTAG_IMAGELENGTH, ly);

    TIFFSetField(tfp, TIFFTAG_ORIENTATION, ORIENTATION_BOTLEFT);

    TIFFSetField(tfp, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);

    TIFFSetField(tfp, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_PALETTE);

    TIFFSetField(tfp, TIFFTAG_COMPRESSION, tif_compression);

    scanline = TIFFScanlineSize(tfp);

    outbuf   = (UCHAR *)image->icon.buffer;

    for (row = 0; row < ly; row++) {

      if (TIFFWriteScanline(tfp, outbuf, row, 0) < 0) {

        // tmsg_error("error writing icon to .tz(up) file");

        goto bad;

      }

      outbuf += scanline;

    }

  }

  return TRUE;

bad:

  return FALSE;

}

/*---------------------------------------------------------------------------*/

static int write_extra(IMAGE *image, TIFF *tfp) {

  int lx, ly, x0, y0, wrapx, row;

  UCHAR *extra;

  UINT tif_compression;

  int rowsperstrip;

  if (!image->pixmap.extra_mask) return TRUE;

  tif_compression = get_output_compression();

  if (!TIFFFlush(tfp)) {

    // tmsg_error("Unable to flush data to .tz(up) file");

    goto bad;

  }

  lx    = image->pixmap.xSBsize;

  ly    = image->pixmap.ySBsize;

  x0    = image->pixmap.xD;

  y0    = image->pixmap.yD;

  wrapx = image->pixmap.xsize;

  TIFFSetField(tfp, TIFFTAG_SUBFILETYPE, 1);

  TIFFSetField(tfp, TIFFTAG_BITSPERSAMPLE, 8);

  TIFFSetField(tfp, TIFFTAG_SAMPLESPERPIXEL, 1);

  TIFFSetField(tfp, TIFFTAG_IMAGEWIDTH, lx);

  TIFFSetField(tfp, TIFFTAG_IMAGELENGTH, ly);

  TIFFSetField(tfp, TIFFTAG_ORIENTATION, ORIENTATION_BOTLEFT);

  TIFFSetField(tfp, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);

  TIFFSetField(tfp, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);

  TIFFSetField(tfp, TIFFTAG_COMPRESSION, tif_compression);

  rowsperstrip = (8 * 1024) / lx; /* contig, 1 byte per pixel */

  NOT_LESS_THAN(1, rowsperstrip)

  TIFFSetField(tfp, TIFFTAG_ROWSPERSTRIP, rowsperstrip);

  extra = image->pixmap.extra + y0 * wrapx + x0;

  for (row = 0; row < ly; row++) {

    if (TIFFWriteScanline(tfp, extra, row, 0) < 0) goto bad;

    extra += wrapx;

  }

  return TRUE;

bad:

  // tmsg_error ("error writing extra information to .tz(up) file");

  return FALSE;

}

/*===========================================================================*/

void next_img_read_with_extra(void) { Next_img_read_with_extra = TRUE; }

/*===========================================================================*/

TImageP TImageReaderTZP::load() {

  /*

FILE *fp;

if ((fp = _wfopen(getFilePath().getWideString().c_str(), L"rb")) == NULL)

{

throw TImageException(getFilePath(),"can't open file");

}

//{

//  fclose(fp);

//  throw TImageException(getFilePath(),"invalid file format");

//}

TRaster32P raster(lx,ly);

TPixel32* row;

TRasterImageP rasImage(raster);

TImageP image(rasImage);

*/

  wstring fn = getFilePath().getWideString();

  TIFF *tfp;

  IMAGE *image = NIL;

  TZUP_FIELDS tzup_f;

  // char pltname[1024];

  USHORT *window = NIL;

  USHORT *palette; /*  [TOONZPALETTE_COUNT] */

  // int max_n_colors, max_n_pencils;

  /*

CHECK_IMAGEDLL_LICENSE_AND_GET_IMG_LICENSE_ATTR

SET_READ_WITH_EXTRA

*/

  Silent_tiff_print_error               = 1;

  Tiff_ignore_missing_internal_colormap = 1;

  tfp                                   = TIFFOpen(fn.c_str(), "r");

  if (!tfp) return TImageP();

  if (!get_tzup_fields(tfp, &tzup_f)) return TImageP();

  /*

if (tzup_f.edu_file && !(Img_license_attr & TA_TOONZ_EDU))

{

char str[1024];

BUILD_EDU_ERROR_STRING(str)

tmsg_error (str);

goto bad;

}

*/

  // image = new IMAGE; // new_img();

  // if (!image)

  //  goto bad;

  if (!TIFFGetField(tfp, TIFFTAG_TOONZPALETTE, &palette)) {

    // image->cmap.info = Tcm_old_default_info;

  } else {

    //// image->cmap.info.tone_offs   = palette[3]; sempre 0

    /*

image->cmap.info.tone_bits   = (UCHAR)palette[4];

image->cmap.info.color_offs  = (UCHAR)palette[5];

image->cmap.info.color_bits  = (UCHAR)palette[6];

image->cmap.info.pencil_offs = (UCHAR)palette[7];

image->cmap.info.pencil_bits = (UCHAR)palette[8];

image->cmap.info.offset_mask = palette[9];

image->cmap.info.n_tones     = 1 << palette[4];

image->cmap.info.n_colors    = palette[10];

image->cmap.info.n_pencils   = palette[11];

image->cmap.info.default_val = (image->cmap.info.n_tones-1) |

                      image->cmap.info.offset_mask;

*/

  }

  /* estendo la palette */

  /*

max_n_colors  = 1 << image->cmap.info.color_bits;

max_n_pencils = 1 << image->cmap.info.pencil_bits;

if (max_n_colors  > image->cmap.info.n_colors ||

max_n_pencils > image->cmap.info.n_pencils)

{

image->cmap.info.n_colors  = max_n_colors;

image->cmap.info.n_pencils = max_n_pencils;

image->cmap.color_n  = image->cmap.info.n_colors;

image->cmap.pencil_n = image->cmap.info.n_pencils;

}

*/

  TRasterCM16P raster(tzup_f.xsize, tzup_f.ysize);

  ///===========

  {

    bool swapNeeded = scanline_needs_swapping(tfp);

    int x0    = tzup_f.x0;

    int y0    = tzup_f.y0;

    int lx    = tzup_f.xSBsize;

    int ly    = tzup_f.ySBsize;