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

// XPM Loader and Writer

//

// Design and implementation by

// - Ryan Rubley (ryan@lostreality.org)

//

// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY

// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES

// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE

// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED

// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT

// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY

// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL

// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER

// THIS DISCLAIMER.

//

// Use at your own risk!

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

#ifdef _MSC_VER 

#pragma warning (disable : 4786) // identifier was truncated to 'number' characters

#endif

// IMPLEMENTATION NOTES:

// ------------------------

// Initial design and implementation by

// - Karl-Heinz Bussian (khbussian@moss.de)

// - Hervé Drolon (drolon@infonie.fr)

// Completely rewritten from scratch by Ryan Rubley (ryan@lostreality.org)

// in order to address the following major fixes:

// * Supports any number of chars per pixel (not just 1 or 2)

// * Files with 2 chars per pixel but <= 256colors are loaded as 256 color (not 24bit)

// * Loads much faster, uses much less memory

// * supports #rgb #rrrgggbbb and #rrrrggggbbbb colors (not just #rrggbb)

// * supports symbolic color names

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

#include "FreeImage.h"

#include "Utilities.h"

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

// Plugin Interface

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

static int s_format_id;

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

// Internal Functions

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

// read in and skip all junk until we find a certain char

static BOOL

FindChar(FreeImageIO *io, fi_handle handle, BYTE look_for) {

  BYTE c;

  io->read_proc(&c, sizeof(BYTE), 1, handle);

  while(c != look_for) {

    if( io->read_proc(&c, sizeof(BYTE), 1, handle) != 1 )

      return FALSE;

  }

  return TRUE;

}

// find start of string, read data until ending quote found, allocate memory and return a string

static char *

ReadString(FreeImageIO *io, fi_handle handle) {

  if( !FindChar(io, handle,'"') )

    return NULL;

  BYTE c;

  std::string s;

  io->read_proc(&c, sizeof(BYTE), 1, handle);

  while(c != '"') {

    s += c;

    if( io->read_proc(&c, sizeof(BYTE), 1, handle) != 1 )

      return NULL;

  }

  char *cstr = (char *)malloc(s.length()+1);

  strcpy(cstr,s.c_str());

  return cstr;

}

static char *

Base92(unsigned int num) {

  static char b92[16]; //enough for more then 64 bits

  static char digit[] = " .XoO+@#$%&*=-;:>,<1234567890qwertyuipasdfghjklzxcvbnmMNBVCZASDFGHJKLPIUYTREWQ!~^/()_`'][{}|";

  b92[15] = '\0';

  int i = 14;

  do {

    b92[i--] = digit[num % 92];

    num /= 92;

  } while( num && i >= 0 );

  return b92+i+1;

}

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

// Plugin Implementation

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

static const char * DLL_CALLCONV

Format() {

  return "XPM";

}

static const char * DLL_CALLCONV

Description() {

  return "X11 Pixmap Format";

}

static const char * DLL_CALLCONV

Extension() {

  return "xpm";

}

static const char * DLL_CALLCONV

RegExpr() {

  return "^[ \\t]*/\\* XPM \\*/[ \\t]$";

}

static const char * DLL_CALLCONV

MimeType() {

  return "image/x-xpixmap";

}

static BOOL DLL_CALLCONV

Validate(FreeImageIO *io, fi_handle handle) {

  char buffer[256];

  // checks the first 256 characters for the magic string

  int count = io->read_proc(buffer, 1, 256, handle);

  if(count <= 9) return FALSE;

  for(int i = 0; i < (count - 9); i++) {

    if(strncmp(&buffer[i], "/* XPM */", 9) == 0)

      return TRUE;

  }

  return FALSE;

}

static BOOL DLL_CALLCONV

SupportsExportDepth(int depth) {

  return (

      (depth == 8) ||

      (depth == 24)

    );

}

static BOOL DLL_CALLCONV

SupportsExportType(FREE_IMAGE_TYPE type) {

  return (type == FIT_BITMAP) ? TRUE : FALSE;

}

static BOOL DLL_CALLCONV

SupportsNoPixels() {

  return TRUE;

}

// ----------------------------------------------------------

static FIBITMAP * DLL_CALLCONV

Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) {

  char msg[256];

    FIBITMAP *dib = NULL;

    if (!handle) return NULL;

    try {

    char *str;

    BOOL header_only = (flags & FIF_LOAD_NOPIXELS) == FIF_LOAD_NOPIXELS;

    //find the starting brace

    if( !FindChar(io, handle,'{') )

      throw "Could not find starting brace";

    //read info string

    str = ReadString(io, handle);

    if(!str)

      throw "Error reading info string";

    int width, height, colors, cpp;

    if( sscanf(str, "%d %d %d %d", &width, &height, &colors, &cpp) != 4 ) {

      free(str);

      throw "Improperly formed info string";

    }

    free(str);

    // check info string

    if((width <= 0) || (height <= 0) || (colors <= 0) || (cpp <= 0)) {

      throw "Improperly formed info string";

    }

        if (colors > 256) {

      dib = FreeImage_AllocateHeader(header_only, width, height, 24, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);

    } else {

      dib = FreeImage_AllocateHeader(header_only, width, height, 8);

    }

    //build a map of color chars to rgb values

    std::map<std::string,FILE_RGBA> rawpal; //will store index in Alpha if 8bpp

    for(int i = 0; i < colors; i++ ) {

      FILE_RGBA rgba;

      str = ReadString(io, handle);

      if(!str || (strlen(str) < (size_t)cpp))

        throw "Error reading color strings";

      std::string chrs(str,cpp); //create a string for the color chars using the first cpp chars

      char *keys = str + cpp; //the color keys for these chars start after the first cpp chars

      //translate all the tabs to spaces

      char *tmp = keys;

      while( strchr(tmp,'\t') ) {

        tmp = strchr(tmp,'\t');

        *tmp++ = ' ';

      }

      //prefer the color visual

      if( strstr(keys," c ") ) {

        char *clr = strstr(keys," c ") + 3;

        while( *clr == ' ' ) clr++; //find the start of the hex rgb value

        if( *clr == '#' ) {

          int red = 0, green = 0, blue = 0, n;

          clr++;

          //end string at first space, if any found

          if( strchr(clr,' ') )

            *(strchr(clr,' ')) = '\0';

          //parse hex color, it can be #rgb #rrggbb #rrrgggbbb or #rrrrggggbbbb

          switch( strlen(clr) ) {

            case 3: n = sscanf(clr,"%01x%01x%01x",&red,&green,&blue);

              red |= (red << 4);

              green |= (green << 4);

              blue |= (blue << 4);

              break;

            case 6: n = sscanf(clr,"%02x%02x%02x",&red,&green,&blue);

              break;

            case 9: n = sscanf(clr,"%03x%03x%03x",&red,&green,&blue);

              red >>= 4;

              green >>= 4;

              blue >>= 4;

              break;

            case 12: n = sscanf(clr,"%04x%04x%04x",&red,&green,&blue);

              red >>= 8;

              green >>= 8;

              blue >>= 8;

              break;

            default:

              n = 0;

              break;

          }

          if( n != 3 ) {

            free(str);

            throw "Improperly formed hex color value";

          }

          rgba.r = (BYTE)red;

          rgba.g = (BYTE)green;

          rgba.b = (BYTE)blue;

        } else if( !strncmp(clr,"None",4) || !strncmp(clr,"none",4) ) {

          rgba.r = rgba.g = rgba.b = 0xFF;

        } else {

          char *tmp = clr;

          //scan forward for each space, if its " x " or " xx " end the string there

          //this means its probably some other visual data beyond that point and not

          //part of the color name.  How many named color end with a 1 or 2 character

          //word? Probably none in our list at least.

          while( (tmp = strchr(tmp,' ')) != NULL ) {

            if( tmp[1] != ' ' ) {

              if( (tmp[2] == ' ') || (tmp[2] != ' ' && tmp[3] == ' ') ) {

                tmp[0] = '\0';

                break;

              }

            }

            tmp++;

          }

          //remove any trailing spaces

          tmp = clr+strlen(clr)-1;

          while( *tmp == ' ' ) {

            *tmp = '\0';

            tmp--;

          }

          if (!FreeImage_LookupX11Color(clr,  &rgba.r, &rgba.g, &rgba.b)) {

            sprintf(msg, "Unknown color name '%s'", str);

            free(str);

            throw msg;

          }

        }

      } else {

        free(str);

        throw "Only color visuals are supported";

      }

      //add color to map

      rgba.a = (BYTE)((colors > 256) ? 0 : i);

      rawpal[chrs] = rgba;

      //build palette if needed

      if( colors <= 256 ) {

        RGBQUAD *pal = FreeImage_GetPalette(dib);

        pal[i].rgbBlue = rgba.b;

        pal[i].rgbGreen = rgba.g;

        pal[i].rgbRed = rgba.r;

      }

      free(str);

    }

    //done parsing color map

    if(header_only) {

      // header only mode

      return dib;

    }

    //read in pixel data

    for(int y = 0; y < height; y++ ) {

      BYTE *line = FreeImage_GetScanLine(dib, height - y - 1);

      str = ReadString(io, handle);

      if(!str)

        throw "Error reading pixel strings";

      char *pixel_ptr = str;

      for(int x = 0; x < width; x++ ) {

        //locate the chars in the color map

        std::string chrs(pixel_ptr,cpp);

        FILE_RGBA rgba = rawpal[chrs];

        if( colors > 256 ) {

          line[FI_RGBA_BLUE] = rgba.b;

          line[FI_RGBA_GREEN] = rgba.g;

          line[FI_RGBA_RED] = rgba.r;

          line += 3;

        } else {

          *line = rgba.a;

          line++;

        }

        pixel_ptr += cpp;

      }

      free(str);

    }

    //done reading pixel data

    return dib;

  } catch(const char *text) {

       FreeImage_OutputMessageProc(s_format_id, text);

       if( dib != NULL )

           FreeImage_Unload(dib);

       return NULL;

    }

}

static BOOL DLL_CALLCONV

Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data) {

  if ((dib != NULL) && (handle != NULL)) {

    char header[] = "/* XPM */\nstatic char *freeimage[] = {\n/* width height num_colors chars_per_pixel */\n\"",

    start_colors[] = "\",\n/* colors */\n\"",

    start_pixels[] = "\",\n/* pixels */\n\"",

    new_line[] = "\",\n\"",

    footer[] = "\"\n};\n",

    buf[256]; //256 is more then enough to sprintf 4 ints into, or the base-92 chars and #rrggbb line

    if( io->write_proc(header, (unsigned int)strlen(header), 1, handle) != 1 )

      return FALSE;

    int width = FreeImage_GetWidth(dib), height = FreeImage_GetHeight(dib), bpp = FreeImage_GetBPP(dib);

    RGBQUAD *pal = FreeImage_GetPalette(dib);

    int x,y;

    //map base92 chrs to the rgb value to create the palette

    std::map<DWORD,FILE_RGB> chrs2color;

    //map 8bpp index or 24bpp rgb value to the base92 chrs to create pixel data

    typedef union {

      DWORD index;

      FILE_RGBA rgba;

    } DWORDRGBA;

    std::map<DWORD,std::string> color2chrs;

    //loop thru entire dib, if new color, inc num_colors and add to both maps

    int num_colors = 0;

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

      BYTE *line = FreeImage_GetScanLine(dib, height - y - 1);

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

        FILE_RGB rgb;

        DWORDRGBA u;

        if( bpp > 8 ) {

          u.rgba.b = rgb.b = line[FI_RGBA_BLUE];

          u.rgba.g = rgb.g = line[FI_RGBA_GREEN];

          u.rgba.r = rgb.r = line[FI_RGBA_RED];

          u.rgba.a = 0;

          line += 3;

        } else {

          u.index = *line;

          rgb.b = pal[u.index].rgbBlue;

          rgb.g = pal[u.index].rgbGreen;

          rgb.r = pal[u.index].rgbRed;

          line++;

        }

        if( color2chrs.find(u.index) == color2chrs.end() ) { //new color

          std::string chrs(Base92(num_colors));

          color2chrs[u.index] = chrs;

          chrs2color[num_colors] = rgb;

          num_colors++;

        }

      }

    }

    int cpp = (int)(log((double)num_colors)/log(92.0)) + 1;

    sprintf(buf, "%d %d %d %d", FreeImage_GetWidth(dib), FreeImage_GetHeight(dib), num_colors, cpp );

    if( io->write_proc(buf, (unsigned int)strlen(buf), 1, handle) != 1 )

      return FALSE;

    if( io->write_proc(start_colors, (unsigned int)strlen(start_colors), 1, handle) != 1 )

      return FALSE;

    //write colors, using map of chrs->rgb

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

      sprintf(buf, "%*s c #%02x%02x%02x", cpp, Base92(x), chrs2color[x].r, chrs2color[x].g, chrs2color[x].b );

      if( io->write_proc(buf, (unsigned int)strlen(buf), 1, handle) != 1 )

        return FALSE;

      if( x == num_colors - 1 ) {

        if( io->write_proc(start_pixels, (unsigned int)strlen(start_pixels), 1, handle) != 1 )

          return FALSE;

      } else {

        if( io->write_proc(new_line, (unsigned int)strlen(new_line), 1, handle) != 1 )

          return FALSE;

      }

    }

    //write pixels, using map of rgb(if 24bpp) or index(if 8bpp)->chrs

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

      BYTE *line = FreeImage_GetScanLine(dib, height - y - 1);

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

        DWORDRGBA u;

        if( bpp > 8 ) {

          u.rgba.b = line[FI_RGBA_BLUE];

          u.rgba.g = line[FI_RGBA_GREEN];

          u.rgba.r = line[FI_RGBA_RED];

          u.rgba.a = 0;

          line += 3;

        } else {

          u.index = *line;

          line++;

        }

        sprintf(buf, "%*s", cpp, (char *)color2chrs[u.index].c_str());

        if( io->write_proc(buf, cpp, 1, handle) != 1 )

          return FALSE;

      }

      if( y == height - 1 ) {

        if( io->write_proc(footer, (unsigned int)strlen(footer), 1, handle) != 1 )

          return FALSE;

      } else {

        if( io->write_proc(new_line, (unsigned int)strlen(new_line), 1, handle) != 1 )

          return FALSE;

      }

    }

    return TRUE;

  } else {

    return FALSE;

  }

}

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

//   Init

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

void DLL_CALLCONV

InitXPM(Plugin *plugin, int format_id)

{

    s_format_id = format_id;

  plugin->format_proc = Format;

  plugin->description_proc = Description;

  plugin->extension_proc = Extension;

  plugin->regexpr_proc = RegExpr;

  plugin->open_proc = NULL;

  plugin->close_proc = NULL;

  plugin->pagecount_proc = NULL;

  plugin->pagecapability_proc = NULL;

  plugin->load_proc = Load;

  plugin->save_proc = Save;

  plugin->validate_proc = Validate;

  plugin->mime_proc = MimeType;

  plugin->supports_export_bpp_proc = SupportsExportDepth;

  plugin->supports_export_type_proc = SupportsExportType;

  plugin->supports_icc_profiles_proc = NULL;

  plugin->supports_no_pixels_proc = SupportsNoPixels;

}