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

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

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

#include <assert.h></assert.h>

#include "toonz.h"

#include "tmsg.h"

#include "file.h"

#include "tiff.h"

#include "tiffio.h"

#include "version.h"

#include "history.h"

#include "colorsdb.h"

#include "ImageP/img_security.h"

#define LATEST_PLT_TYPE 4

static int Next_img_read_plt_without_buffer = FALSE;

static int Read_without_buffer              = FALSE;

#define SET_READ_WITHOUT_BUFFER                                                \

  {                                                                            \

    Read_without_buffer              = Next_img_read_plt_without_buffer;       \

    Next_img_read_plt_without_buffer = FALSE;                                  \

  }

#ifdef VECCHIA_MANIERA

static char *build_string_names(IMAGE *image);

static void set_color_names(IMAGE *image, char *names);

static char *plt_find_color_name(IMAGE *img, int color);

static char *plt_find_pencil_name(IMAGE *img, int color);

static void plt_set_color_name(IMAGE *img, int color, char *name);

static void plt_set_pencil_name(IMAGE *img, int pencil, char *name);

#endif

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

int img_write_plt(char *filename, IMAGE *image) {

  TIFF *tfp;

  UCHAR *buffer;

  int i, j, scanline, width, rows_per_strip;

  LPIXEL *cmap, *color, *pencil;

  USHORT palette[TOONZPALETTE_COUNT];

  char *names, *history;

  int plt_type, cmap_size;

  CHECK_IMAGEDLL_LICENSE_AND_GET_IMG_LICENSE_ATTR

  names = NIL;

  if (image->type != CMAP) return FALSE;

  tfp = TIFFOpen(filename, "w");

  if (!tfp) return FALSE;

  plt_type = (image->cmap.offset > 0) ? 4 : 3;

  if (!image->cmap.info.n_colors) {

    assert(plt_type == 4);

    image->cmap.info           = Tcm_old_default_info;

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

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

    cmap_size                  = TCM_MIN_CMAP_BUFFER_SIZE(image->cmap.info);

  } else {

    cmap_size = TCM_CMAP_BUFFER_SIZE(image->cmap.info);

  }

  palette[0]  = plt_type;

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

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

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

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

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

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

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

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

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

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

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

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

  palette[TOONZPALETTE_COUNT - 1] = (Img_license_attr & TA_TOONZ_EDU) != 0;

  TIFFSetField(tfp, TIFFTAG_TOONZPALETTE, palette);

  if (plt_type == 3) {

    assert(image->cmap.color && image->cmap.pencil);

    width = image->cmap.color_n + image->cmap.pencil_n;

  } else {

    if (image->cmap.color && image->cmap.pencil)

      width = cmap_size + image->cmap.color_n + image->cmap.pencil_n;

    else

      width = cmap_size;

  }

  TIFFSetField(tfp, TIFFTAG_BITSPERSAMPLE, 8);

  TIFFSetField(tfp, TIFFTAG_SAMPLESPERPIXEL, 4);

  TIFFSetField(tfp, TIFFTAG_IMAGEWIDTH, width);

  TIFFSetField(tfp, TIFFTAG_IMAGELENGTH, 1);

  TIFFSetField(tfp, TIFFTAG_COMPRESSION, COMPRESSION_NONE);

  TIFFSetField(tfp, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);

  TIFFSetField(tfp, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);

#ifdef VECCHIA_MANIERA

  names_pointer = (TREE *)image->cmap.names;

  image->cmap.names =

      cdb_encode_names((TREE *)image->cmap.names, &(image->cmap.names_max));

  str                  = build_string_names(image);

  names_string_pointer = (char *)image->cmap.names;

  image->cmap.names    = (USHORT *)names_pointer;

  if (names_string_pointer) free(names_string_pointer);

#endif

  names = cdb_encode_all(image->cmap.names);

  TIFFSetField(tfp, TIFFTAG_TOONZCOLORNAMES, names);

  /* Aggiungo History */

  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:

      printf("Internal error: bad history type; aborting...\n");

      abort();

    }

    free(history);

  } else

    image->history = history;

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

  scanline = TIFFScanlineSize(tfp);

  /*

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

* vedi Graphics File Formats pag.48

*/

  rows_per_strip = (8 * 1024) / scanline;

  TIFFSetField(tfp, TIFFTAG_ROWSPERSTRIP,

               rows_per_strip == 0 ? 1L : rows_per_strip);

  TMALLOC(buffer, scanline);

  cmap   = image->cmap.buffer;

  color  = image->cmap.color;

  pencil = image->cmap.pencil;

  switch (plt_type) {

    CASE 1

        : printf(

              "img_rwite_plt error: type 1 .plt's are not written any more\n");

    abort();

    CASE 2 : __OR 4 : for (i = 0, j = 0; i < cmap_size; i++, j += 4) {

      buffer[j + 0] = cmap[i].r;

      buffer[j + 1] = cmap[i].g;

      buffer[j + 2] = cmap[i].b;

      buffer[j + 3] = cmap[i].m;

    }

    if (width > cmap_size) {

      for (i = 0; i < image->cmap.color_n; i++, j += 4) {

        buffer[j + 0] = color[i].r;

        buffer[j + 1] = color[i].g;

        buffer[j + 2] = color[i].b;

        buffer[j + 3] = color[i].m;

      }

      for (i = 0; i < image->cmap.pencil_n; i++, j += 4) {

        buffer[j + 0] = pencil[i].r;

        buffer[j + 1] = pencil[i].g;

        buffer[j + 2] = pencil[i].b;

        buffer[j + 3] = pencil[i].m;

      }

    }

    CASE 3 : for (i = 0, j = 0; i < image->cmap.color_n; i++, j += 4) {

      buffer[j + 0] = color[i].m; /* different from type 2 */

      buffer[j + 1] = color[i].b;

      buffer[j + 2] = color[i].g;

      buffer[j + 3] = color[i].r;

    }

    for (i = 0; i < image->cmap.pencil_n; i++, j += 4) {

      buffer[j + 0] = pencil[i].m;

      buffer[j + 1] = pencil[i].b;

      buffer[j + 2] = pencil[i].g;

      buffer[j + 3] = pencil[i].r;

    }

  DEFAULT:

    assert(!"bad palette type");

  }

  if (TIFFWriteScanline(tfp, buffer, 0, 0) < 0) goto bad;

  TFREE(buffer);

  TIFFClose(tfp);

  TFREE(names);

  return TRUE;

bad:

  TFREE(buffer);

  TIFFClose(tfp);

  TFREE(names);

  return FALSE;

}

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

void next_img_read_plt_without_buffer(void) {

  Next_img_read_plt_without_buffer = TRUE;

}

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

IMAGE *img_read_plt(char *filename) {

  int with_cmap_buffer;

  IMAGE *image = NIL;

  TIFF *tfp;

  UCHAR *buffer = NIL;

  int i, j, scanline;

  LPIXEL *cmap;

  USHORT *palette; /*  [TOONZPALETTE_COUNT] */

  USHORT spp, bps, comp, plan_con, photom;

  int width, height;

  char *names;

  int plt_type, m, cmap_file_size, cmap_alloc_size;

  int colpen_cmap, colbuf_alloc_size, penbuf_alloc_size;

  int max_n_colors, max_n_pencils;

  int act_n_colors, act_n_pencils, index;

  LPIXEL grey, black;

  TBOOL edu_file;

  CHECK_IMAGEDLL_LICENSE_AND_GET_IMG_LICENSE_ATTR

  SET_READ_WITHOUT_BUFFER

  tfp = TIFFOpen(filename, "r");

  if (!tfp) return NIL;

  TIFFGetField(tfp, TIFFTAG_TOONZPALETTE, &palette);

  TIFFGetField(tfp, TIFFTAG_TOONZCOLORNAMES, &names);

  TIFFGetField(tfp, TIFFTAG_BITSPERSAMPLE, &bps);

  TIFFGetField(tfp, TIFFTAG_SAMPLESPERPIXEL, &spp);

  TIFFGetField(tfp, TIFFTAG_IMAGEWIDTH, &width);

  TIFFGetField(tfp, TIFFTAG_IMAGELENGTH, &height);

  TIFFGetField(tfp, TIFFTAG_COMPRESSION, &comp);

  TIFFGetField(tfp, TIFFTAG_PLANARCONFIG, &plan_con);

  TIFFGetField(tfp, TIFFTAG_PHOTOMETRIC, &photom);

  if (photom != PHOTOMETRIC_RGB || plan_con != PLANARCONFIG_CONTIG) goto bad;

  edu_file = palette[TOONZPALETTE_COUNT - 1] & 1;

  if (edu_file && !(Img_license_attr & TA_TOONZ_EDU)) {

    char str[1024];

    BUILD_EDU_ERROR_STRING(str)

    tmsg_error(str);

    goto bad;

  }

  scanline = TIFFScanlineSize(tfp);

  image = new_img();

  if (!image) goto bad;

  image->type = CMAP;

  /* Leggo history */

  if (!TIFFGetField(tfp, TIFFTAG_TOONZHISTORY, &image->history))

    image->history = "";

  image->history   = strsave(image->history);

  plt_type             = palette[0];

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

  image->cmap.color_n  = palette[10];

  image->cmap.pencil_n = palette[11];

  image->cmap.info = Tcm_old_default_info;

  if (palette[6]) {

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

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

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

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

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

    image->cmap.info.pencil_bits = 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;

  cmap_alloc_size   = TCM_CMAP_BUFFER_SIZE(image->cmap.info);

  cmap_file_size    = palette[2] ? palette[2] : cmap_alloc_size;

  colpen_cmap       = image->cmap.info.n_tones > 16;

  colbuf_alloc_size = TCM_CMAP_COLBUFFER_SIZE(image->cmap.info);

  penbuf_alloc_size = TCM_CMAP_PENBUFFER_SIZE(image->cmap.info);

  TMALLOC(buffer, scanline);

  if (!buffer) goto bad;

  with_cmap_buffer = !Read_without_buffer || (plt_type <= 2) || (plt_type == 4);

  if (with_cmap_buffer) {

    if (colpen_cmap) {

      TMALLOC(image->cmap.colbuffer, colbuf_alloc_size);

      TMALLOC(image->cmap.penbuffer, penbuf_alloc_size);

      if (!image->cmap.colbuffer || !image->cmap.penbuffer) goto bad;

    } else {

      TMALLOC(image->cmap.buffer, cmap_alloc_size);

      if (!image->cmap.buffer) goto bad;

    }

  }

  TCALLOC(image->cmap.color, 1 << image->cmap.info.color_bits);

  if (!image->cmap.color) goto bad;

  TCALLOC(image->cmap.pencil, 1 << image->cmap.info.pencil_bits);

  if (!image->cmap.pencil) goto bad;

  if (TIFFReadScanline(tfp, buffer, 0, 0) < 0) goto bad;

  switch (plt_type) {

    CASE 1 : if (!with_cmap_buffer) {

      TCALLOC(image->cmap.buffer, cmap_alloc_size)

      if (!image->cmap.buffer) goto bad;

    }

    for (i = 0, j = 0; i < cmap_file_size; i++, j += 4) {

      image->cmap.buffer[i].r = buffer[j + 0];

      image->cmap.buffer[i].g = buffer[j + 1];

      image->cmap.buffer[i].b = buffer[j + 2];

    }

    to_new_cmap(&image->cmap);

    set_colors_and_pencils(&image->cmap);

    if (!with_cmap_buffer) TFREE(image->cmap.buffer)

    CASE 2 : __OR 4

             : if (with_cmap_buffer) for (i = 0, j = 0; i < cmap_file_size;

                                          i++, j += 4) {

      image->cmap.buffer[i].r = buffer[j + 0];

      image->cmap.buffer[i].g = buffer[j + 1];

      image->cmap.buffer[i].b = buffer[j + 2];

      image->cmap.buffer[i].m = buffer[j + 3];

    }

    else j = 4 * cmap_file_size;

    if (width > cmap_file_size) {

      for (i = 0; i < image->cmap.color_n; i++, j += 4) {

        image->cmap.color[i].r = buffer[j + 0];

        image->cmap.color[i].g = buffer[j + 1];

        image->cmap.color[i].b = buffer[j + 2];

        image->cmap.color[i].m = buffer[j + 3];

      }

      for (i = 0; i < image->cmap.pencil_n; i++, j += 4) {

        image->cmap.pencil[i].r = buffer[j + 0];

        image->cmap.pencil[i].g = buffer[j + 1];

        image->cmap.pencil[i].b = buffer[j + 2];

        image->cmap.pencil[i].m = buffer[j + 3];

      }

    } else

      set_colors_and_pencils(&image->cmap);

    CASE 3 : for (i = 0, j = 0; i < image->cmap.color_n; i++, j += 4) {

      image->cmap.color[i].m = buffer[j + 0]; /* different from type 2 */

      image->cmap.color[i].b = buffer[j + 1];

      image->cmap.color[i].g = buffer[j + 2];

      image->cmap.color[i].r = buffer[j + 3];

    }

    for (i = 0; i < image->cmap.pencil_n; i++, j += 4) {

      image->cmap.pencil[i].m = buffer[j + 0];

      image->cmap.pencil[i].b = buffer[j + 1];

      image->cmap.pencil[i].g = buffer[j + 2];

      image->cmap.pencil[i].r = buffer[j + 3];

    }

    if (with_cmap_buffer)

      if (colpen_cmap) {

        memset(image->cmap.colbuffer, 0, colbuf_alloc_size * sizeof(LPIXEL));

        memset(image->cmap.penbuffer, 0, penbuf_alloc_size * sizeof(LPIXEL));

        fill_cmap_colbuffer(image->cmap.colbuffer, image->cmap.info,

                            image->cmap.color, FALSE);

        fill_cmap_penbuffer(image->cmap.penbuffer, image->cmap.info,

                            image->cmap.pencil, FALSE);

      } else {

        memset(image->cmap.buffer, 0, cmap_alloc_size * sizeof(LPIXEL));

        fill_cmap_buffer(image->cmap.buffer, image->cmap.info,

                         image->cmap.color, image->cmap.pencil, FALSE);

      }

  DEFAULT:

    goto bad;

  }

#ifdef VECCHIA_MANIERA

  set_color_names(image, names);

  names_pointer = image->cmap.names;

  image->cmap.names =

      (USHORT *)cdb_decode_names(image->cmap.names, image->cmap.names_max);

  TFREE(names_pointer);

#endif

  image->cmap.names = cdb_decode_all(names, image->cmap.info);

  /* 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) {

    act_n_colors               = image->cmap.info.n_colors;

    act_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;

    grey.r = grey.g = grey.b = 127;

    grey.m                   = 255;

    black.r = black.g = black.b = 0;

    black.m                     = 255;

    for (i = act_n_colors; i < max_n_colors; i++) {

      image->cmap.color[i] = grey;

      index                = TCM_COLOR_INDEX(image->cmap.info, i);

      cdb_set_group(image, index, UNUSED_COLOR_PAGE_NAME);

      if (with_cmap_buffer && colpen_cmap)

        fill_cmap_colramp(image->cmap.colbuffer, image->cmap.info,

                          image->cmap.color[i], i, FALSE);

    }

    for (i = act_n_pencils; i < max_n_pencils; i++) {

      image->cmap.pencil[i] = black;

      index                 = TCM_PENCIL_INDEX(image->cmap.info, i);

      cdb_set_group(image, index, UNUSED_COLOR_PAGE_NAME);

      if (with_cmap_buffer && colpen_cmap)

        fill_cmap_penramp(image->cmap.penbuffer, image->cmap.info,

                          image->cmap.pencil[i], i, FALSE);

    }

    if (with_cmap_buffer && !colpen_cmap)

      fill_cmap_buffer(image->cmap.buffer, image->cmap.info, image->cmap.color,

                       image->cmap.pencil, FALSE);

  }

  if (buffer) TFREE(buffer);

  TIFFClose(tfp);

  return image;

bad:

  if (image) free_img(image);

  TFREE(buffer);

  TIFFClose(tfp);

  return NIL;

}

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

IMAGE *img_read_plt_info(char *filename) {

  IMAGE *image = NIL;

  TIFF *tfp;

  USHORT *palette; /*  [TOONZPALETTE_COUNT] */

  USHORT plan_con, photom;

  char *names;

  int max_n_colors, max_n_pencils;

  TBOOL edu_file;

  CHECK_IMAGEDLL_LICENSE_AND_GET_IMG_LICENSE_ATTR

  tfp = TIFFOpen(filename, "r");

  if (!tfp) return NIL;

  TIFFGetField(tfp, TIFFTAG_TOONZPALETTE, &palette);

  TIFFGetField(tfp, TIFFTAG_TOONZCOLORNAMES, &names);

  TIFFGetField(tfp, TIFFTAG_PLANARCONFIG, &plan_con);

  TIFFGetField(tfp, TIFFTAG_PHOTOMETRIC, &photom);

  if (photom != PHOTOMETRIC_RGB || plan_con != PLANARCONFIG_CONTIG) goto bad;

  edu_file = palette[TOONZPALETTE_COUNT - 1] & 1;

  if (edu_file && !(Img_license_attr & TA_TOONZ_EDU)) {

    char str[1024];

    BUILD_EDU_ERROR_STRING(str)

    tmsg_warning(str);

  }

  image = new_img();

  if (!image) goto bad;

  image->type = CMAP;

  if (palette[0] < 1 || palette[0] > LATEST_PLT_TYPE) goto bad;

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

  image->cmap.color_n  = palette[10];

  image->cmap.pencil_n = palette[11];

  image->cmap.info = Tcm_old_default_info;

  if (palette[6]) {

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

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

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

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

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

    image->cmap.info.pencil_bits = 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;

  /* Leggo history */

  if (!TIFFGetField(tfp, TIFFTAG_TOONZHISTORY, &image->history))

    image->history = "";

  image->history   = strsave(image->history);

  /* 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;

  }

  image->cmap.names = cdb_decode_all(names, image->cmap.info);

  TIFFClose(tfp);

  return image;

bad:

  if (image) free_img(image);

  TIFFClose(tfp);

  return NIL;

}

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

/* Attenzione: se si modifica questa funzione, occore riportare le

 *             variazioni nella libreria line x line (simg_plt.c)

 */

#ifdef VECCHIA_MANIERA

static char *plt_find_color_name(IMAGE *img, int color) {

  char *name;

  int index;

  index = TCM_COLOR_INDEX(img->cmap.info, color);

  name  = find_color_name(img, index);

  return name;

}

#endif

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

/* Attenzione: se si modifica questa funzione, occore riportare le

 *             variazioni nella libreria line x line (simg_plt.c)

 */

#ifdef VECCHIA_MANIERA

static char *plt_find_pencil_name(IMAGE *img, int pencil) {

  char *name;

  int index;

  index = TCM_PENCIL_INDEX(img->cmap.info, pencil);

  name  = find_color_name(img, index);

  return name;

}

#endif

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

/* Attenzione: se si modifica questa funzione, occore riportare le

 *             variazioni nella libreria line x line (simg_plt.c)

 */

#ifdef VECCHIA_MANIERA

static void plt_set_color_name(IMAGE *img, int color, char *name) {

  int index;

  index = TCM_COLOR_INDEX(img->cmap.info, color);

  set_color_name(img, index, name);

}

#endif

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

/* Attenzione: se si modifica questa funzione, occore riportare le

 *             variazioni nella libreria line x line (simg_plt.c)

 */

#ifdef VECCHIA_MANIERA

static void plt_set_pencil_name(IMAGE *img, int pencil, char *name) {

  int index;

  index = TCM_PENCIL_INDEX(img->cmap.info, pencil);

  set_color_name(img, index, name);

}

#endif

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

/* Attenzione: se si modifica questa funzione, occore riportare le

 *             variazioni nella libreria line x line (simg_plt.c)

 */

#ifdef VECCHIA_MANIERA

static char *build_string_names(IMAGE *image) {

  char *str, *name;

  int i, maxsize = 1000, ptr, len;

  str = (char *)malloc(maxsize);

  ptr = 0;

  for (i = 0; i < image->cmap.color_n; i++) {

    name = plt_find_color_name(image, i);

    if (name && *name) {

      len = strlen(name);

      if ((len + ptr) >= maxsize) {

        maxsize += 200;

        str = (char *)realloc(str, maxsize);

      }

      memmove(str + ptr, name, len);

      ptr += len;

    }

    if (ptr + 1 >= maxsize) {

      maxsize += 200;

      str = (char *)realloc(str, maxsize);

    }

    memmove(str + ptr, "|", 1);

    ptr++;

  }

  for (i = 0; i < image->cmap.pencil_n; i++) {

    name = plt_find_pencil_name(image, i);

    if (name && *name) {

      len = strlen(name);

      if ((len + ptr) >= maxsize) {

        maxsize += 200;

        str = (char *)realloc(str, maxsize);

      }

      memmove(str + ptr, name, len);

      ptr += len;

    }

    if (ptr + 1 >= maxsize) {

      maxsize += 200;

      str = (char *)realloc(str, maxsize);

    }

    memmove(str + ptr, "|", 1);

    ptr++;

  }

  str[ptr] = 0;

  return str;

}

#endif

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

/* Attenzione: se si modifica questa funzione, occore riportare le

 *             variazioni nella libreria line x line (simg_plt.c)

 */

#ifdef VECCHIA_MANIERA

static void set_color_names(IMAGE *image, char *names) {

  int i;

  char *s, *name;

  s = names;

  i = 0;

  while (*s) {

    name = NULL;

    if (*s != '|') {

      name = s;

      while (*s && *s != '|') s++;

      *s = 0;

    }

    if (name) {

      if (i < image->cmap.info.n_colors)

        plt_set_color_name(image, i, name);

      else

        plt_set_pencil_name(image, i - image->cmap.info.n_colors, name);

    }

    i++;

    s++;

  }

}

#endif