[BACK]Return to image.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/image.C between versions 1.4 and 1.174

version 1.4, 2001/04/10 14:18:28 version 1.174, 2020/12/03 22:48:09
Line 1 Line 1
 /** @file  /** @file
         Parser: @b image parser class.          Parser: @b image parser class.
   
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001-2017 Art. Lebedev Studio (http://www.artlebedev.com)
           Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
         Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)  */
   
         $Id$  /*
           jpegsize: gets the width and height (in pixels) of a jpeg file
           Andrew Tong, werdna@ugcs.caltech.edu           February 14, 1995
           modified slightly by alex@ed.ac.uk
           and further still by rjray@uswest.com
           optimization and general re-write from tmetro@vl.com
           from perl by paf@design.ru
 */  */
   
 #include "pa_config_includes.h"  #include "pa_config_includes.h"
   #include "gif.h"
   
 #ifdef WIN32  #include "pa_vmethod_frame.h"
 #       include "smtp/smtp.h"  
 #endif  
   
 #include "pa_common.h"  #include "pa_common.h"
 #include "pa_request.h"  #include "pa_request.h"
 #include "pa_vfile.h"  #include "pa_vfile.h"
 #include "pa_vimage.h"  #include "pa_vimage.h"
   #include "pa_vdate.h"
   #include "pa_table.h"
   #include "pa_charsets.h"
   
   volatile const char * IDENT_IMAGE_C="$Id$";
   
   // defines
   
   static const String spacebar_width_name("space");
   static const String monospace_width_name("width");
   static const String letter_spacing_name("spacing");
   
   // class
   
   class MImage: public Methoded {
   public: // VStateless_class
           Value* create_new_value(Pool&) { return new VImage(); }
   
   public:
           MImage();
   };
   
 // global var  // globals
   
 VStateless_class *image_class;  DECLARE_CLASS_VAR(image, new MImage);
   
 // helpers  // helpers
   
   #define EXIF_TAG(tag, name) put(tag, #name);
   
   /// value of exif tag -> it's value
   class EXIF_tag_value2name: public Hash<int, const char*> {
   public:
           EXIF_tag_value2name() {
           // image JPEG Exif
                   // Tags used by IFD0 (main image)
                   EXIF_TAG(0x010e,        ImageDescription);
                   EXIF_TAG(0x010f,        Make);
                   EXIF_TAG(0x0110,        Model);
                   EXIF_TAG(0x0112,        Orientation);
                   EXIF_TAG(0x011a,        XResolution);
                   EXIF_TAG(0x011b,        YResolution);
                   EXIF_TAG(0x0128,        ResolutionUnit);
                   EXIF_TAG(0x0131,        Software);
                   EXIF_TAG(0x0132,        DateTime);
                   EXIF_TAG(0x013e,        WhitePoint);
                   EXIF_TAG(0x013f,        PrimaryChromaticities);
                   EXIF_TAG(0x0211,        YCbCrCoefficients);
                   EXIF_TAG(0x0213,        YCbCrPositioning);
                   EXIF_TAG(0x0214,        ReferenceBlackWhite);
                   EXIF_TAG(0x8298,        Copyright);
                   EXIF_TAG(0x8769,        ExifOffset);
                   // Tags used by Exif SubIFD
                   EXIF_TAG(0x829a,        ExposureTime);
                   EXIF_TAG(0x829d,        FNumber);
                   EXIF_TAG(0x8822,        ExposureProgram);
                   EXIF_TAG(0x8827,        ISOSpeedRatings);
                   EXIF_TAG(0x9000,        ExifVersion);
                   EXIF_TAG(0x9003,        DateTimeOriginal);
                   EXIF_TAG(0x9004,        DateTimeDigitized);
                   EXIF_TAG(0x9101,        ComponentsConfiguration);
                   EXIF_TAG(0x9102,        CompressedBitsPerPixel);
                   EXIF_TAG(0x9201,        ShutterSpeedValue);
                   EXIF_TAG(0x9202,        ApertureValue);
                   EXIF_TAG(0x9203,        BrightnessValue);
                   EXIF_TAG(0x9204,        ExposureBiasValue);
                   EXIF_TAG(0x9205,        MaxApertureValue);
                   EXIF_TAG(0x9206,        SubjectDistance);
                   EXIF_TAG(0x9207,        MeteringMode);
                   EXIF_TAG(0x9208,        LightSource);
                   EXIF_TAG(0x9209,        Flash);
                   EXIF_TAG(0x920a,        FocalLength);
                   EXIF_TAG(0x927c,        MakerNote);
                   EXIF_TAG(0x9286,        UserComment);
                   EXIF_TAG(0x9290,        SubsecTime);
                   EXIF_TAG(0x9291,        SubsecTimeOriginal);
                   EXIF_TAG(0x9292,        SubsecTimeDigitized);
                   EXIF_TAG(0xa000,        FlashPixVersion);
                   EXIF_TAG(0xa001,        ColorSpace);
                   EXIF_TAG(0xa002,        ExifImageWidth);
                   EXIF_TAG(0xa003,        ExifImageHeight);
                   EXIF_TAG(0xa004,        RelatedSoundFile);
                   EXIF_TAG(0xa005,        ExifInteroperabilityOffset);
                   EXIF_TAG(0xa20e,        FocalPlaneXResolution);
                   EXIF_TAG(0xa20f,        FocalPlaneYResolution);
                   EXIF_TAG(0xa210,        FocalPlaneResolutionUnit);
                   EXIF_TAG(0xa215,        ExposureIndex);
                   EXIF_TAG(0xa217,        SensingMethod);
                   EXIF_TAG(0xa300,        FileSource);
                   EXIF_TAG(0xa301,        SceneType);
                   EXIF_TAG(0xa302,        CFAPattern);
                   // Misc Tags
                   EXIF_TAG(0x00fe,        NewSubfileType);
                   EXIF_TAG(0x00ff,        SubfileType);
                   EXIF_TAG(0x012d,        TransferFunction);
                   EXIF_TAG(0x013b,        Artist);
                   EXIF_TAG(0x013d,        Predictor);
                   EXIF_TAG(0x0142,        TileWidth);
                   EXIF_TAG(0x0143,        TileLength);
                   EXIF_TAG(0x0144,        TileOffsets);
                   EXIF_TAG(0x0145,        TileByteCounts);
                   EXIF_TAG(0x014a,        SubIFDs);
                   EXIF_TAG(0x015b,        JPEGTables);
                   EXIF_TAG(0x828d,        CFARepeatPatternDim);
                   EXIF_TAG(0x828e,        CFAPattern);
                   EXIF_TAG(0x828f,        BatteryLevel);
                   EXIF_TAG(0x83bb,        IPTC/NAA);
                   EXIF_TAG(0x8773,        InterColorProfile);
                   EXIF_TAG(0x8824,        SpectralSensitivity);
                   //EXIF_TAG(0x8825,      GPSInfo);
                   EXIF_TAG(0x8828,        OECF);
                   EXIF_TAG(0x8829,        Interlace);
                   EXIF_TAG(0x882a,        TimeZoneOffset);
                   EXIF_TAG(0x882b,        SelfTimerMode);
                   EXIF_TAG(0x920b,        FlashEnergy);
                   EXIF_TAG(0x920c,        SpatialFrequencyResponse);
                   EXIF_TAG(0x920d,        Noise);
                   EXIF_TAG(0x9211,        ImageNumber);
                   EXIF_TAG(0x9212,        SecurityClassification);
                   EXIF_TAG(0x9213,        ImageHistory);
                   EXIF_TAG(0x9214,        SubjectLocation);
                   EXIF_TAG(0x9215,        ExposureIndex);
                   EXIF_TAG(0x9216,        TIFF/EPStandardID);
                   EXIF_TAG(0xa20b,        FlashEnergy);
                   EXIF_TAG(0xa20c,        SpatialFrequencyResponse);
                   EXIF_TAG(0xa214,        SubjectLocation);
   
                   // additional things added by misha@
                   EXIF_TAG(0x0100,        ImageWidth);
                   EXIF_TAG(0x0101,        ImageLength);
                   EXIF_TAG(0x0102,        BitsPerSample);
                   EXIF_TAG(0x0103,        Compression);
                   EXIF_TAG(0x0106,        PhotometricInterpretation);
                   EXIF_TAG(0x010a,        FillOrder);
                   EXIF_TAG(0x010d,        DocumentName);
                   EXIF_TAG(0x0111,        StripOffsets);
                   EXIF_TAG(0x0115,        SamplesPerPixel);
                   EXIF_TAG(0x0116,        RowsPerStrip);
                   EXIF_TAG(0x0117,        StripByteCounts);
                   EXIF_TAG(0x011c,        PlanarConfiguration);
                   EXIF_TAG(0x0156,        TransferRange);
                   EXIF_TAG(0x0200,        JPEGProc);
                   EXIF_TAG(0x0201,        JPEGInterchangeFormat);
                   EXIF_TAG(0x0202,        JPEGInterchangeFormatLength);
                   EXIF_TAG(0x0212,        YCbCrSubSampling);
                   EXIF_TAG(0xa401,        CustomRendered);
                   EXIF_TAG(0xa402,        ExposureMode);
                   EXIF_TAG(0xa403,        WhiteBalance);
                   EXIF_TAG(0xa404,        DigitalZoomRatio);
                   EXIF_TAG(0xa405,        FocalLengthIn35mmFilm);
                   EXIF_TAG(0xa406,        SceneCaptureType);
                   EXIF_TAG(0xa407,        GainControl);
                   EXIF_TAG(0xa408,        Contrast);
                   EXIF_TAG(0xa409,        Saturation);
                   EXIF_TAG(0xa40a,        Sharpness);
                   EXIF_TAG(0xa40b,        DeviceSettingDescription);
                   EXIF_TAG(0xa40c,        SubjectDistanceRange);
                   EXIF_TAG(0xa420,        ImageUniqueID);
   
                   // other tags
                   EXIF_TAG(0xa430,        CameraOwnerName);
                   EXIF_TAG(0xa431,        BodySerialNumber);
                   EXIF_TAG(0xa432,        LensSpecification);
                   EXIF_TAG(0xa433,        LensManufactor);
                   EXIF_TAG(0xa434,        LensModel);
                   EXIF_TAG(0xa435,        LensSerialNumber);
           }
   } exif_tag_value2name;
   
   class EXIF_gps_tag_value2name: public Hash<int, const char*> {
   public:
                   EXIF_gps_tag_value2name() {
                   EXIF_TAG(0x0,   GPSVersionID);
                   EXIF_TAG(0x1,   GPSLatitudeRef);
                   EXIF_TAG(0x2,   GPSLatitude);
                   EXIF_TAG(0x3,   GPSLongitudeRef);
                   EXIF_TAG(0x4,   GPSLongitude);
                   EXIF_TAG(0x5,   GPSAltitudeRef);
                   EXIF_TAG(0x6,   GPSAltitude);
                   EXIF_TAG(0x7,   GPSTimeStamp);
                   EXIF_TAG(0x8,   GPSSatellites);
                   EXIF_TAG(0x9,   GPSStatus);
                   EXIF_TAG(0xA,   GPSMeasureMode);
                   EXIF_TAG(0xB,   GPSDOP);
                   EXIF_TAG(0xC,   GPSSpeedRef);
                   EXIF_TAG(0xD,   GPSSpeed);
                   EXIF_TAG(0xE,   GPSTrackRef);
                   EXIF_TAG(0xF,   GPSTrack);
                   EXIF_TAG(0x10,  GPSImgDirectionRef);
                   EXIF_TAG(0x11,  GPSImgDirection);
                   EXIF_TAG(0x12,  GPSMapDatum);
                   EXIF_TAG(0x13,  GPSDestLatitudeRef);
                   EXIF_TAG(0x14,  GPSDestLatitude);
                   EXIF_TAG(0x15,  GPSDestLongitudeRef);
                   EXIF_TAG(0x16,  GPSDestLongitude);
                   EXIF_TAG(0x17,  GPSDestBearingRef);
                   EXIF_TAG(0x18,  GPSDestBearing);
                   EXIF_TAG(0x19,  GPSDestDistanceRef);
                   EXIF_TAG(0x1A,  GPSDestDistance);
                   EXIF_TAG(0x1B,  GPSProcessingMethod);
                   EXIF_TAG(0x1C,  GPSAreaInformation);
                   EXIF_TAG(0x1D,  GPSDateStamp);
                   EXIF_TAG(0x1E,  GPSDifferential);
           }
   } exif_gps_tag_value2name;
   
   
   ///*********************************************** support functions
   
 class Measure_reader {  class Measure_reader {
 public:  public:
         enum { READ_CHUNK_SIZE=0x400 }; // 1K          virtual size_t read(const char* &buf, size_t limit)=0;
         typedef size_t (*Func)(void *& buf, size_t limit, void *info);          virtual void seek(uint64_t value)=0;
           virtual uint64_t tell()=0;
           virtual uint64_t length()=0;
   };
   
   class Measure_file_reader: public Measure_reader {
           const String& file_name;
           int f;
   
         Measure_reader(Func afunc, void *ainfo) :   public:
                 func(afunc), info(ainfo),           Measure_file_reader(int af, const String& afile_name):
                 chunk(0), offset(0), size(0) {                  file_name(afile_name), f(af) {
         }          }
   
         size_t read(unsigned char *& buf, size_t limit) {          override size_t read(const char* &abuf, size_t limit) {
                 if(offset+limit>size) // nothing left                  if(limit==0)
                         if(offset==0 || limit==1) { // only one-byte continuations allowed  
                                 size=(*func)(chunk, READ_CHUNK_SIZE, info);  
                                 offset=0;  
                         } else  
                                 return 0; // as if EOF  
                 if(!size) // EOF  
                         return 0;                          return 0;
                           
                 // something left                  char* lbuf=new(PointerFreeGC) char[limit];
                 size_t read_size=min(offset+limit, size)-offset;                  ssize_t read_size=::read(f, lbuf, limit);  abuf=lbuf;
                 buf=((unsigned char *)chunk)+offset;                  if(read_size<0)
                 offset+=read_size;                          throw Exception(0, &file_name, "measure read failed: %s (%d)", strerror(errno), errno);
                 return read_size;                  return read_size;
         }          }
   
 private:          override void seek(uint64_t value) {
         Func func;                  if(pa_lseek(f, value, SEEK_SET)<0)
         void *info;                          throw Exception(IMAGE_FORMAT, &file_name, "seek to %.15g failed: %s (%d)", (double)value, strerror(errno), errno);
           }
   
           override uint64_t tell() { return pa_lseek(f, 0, SEEK_CUR); }
   
           override uint64_t length() { return pa_lseek(f, 0, SEEK_END); }
   
   };
   
   class Measure_buf_reader: public Measure_reader {
   
           const char* buf; size_t size;
           const String& file_name; 
   
         void *chunk;  
         size_t offset;          size_t offset;
         size_t size;  
   public:
           Measure_buf_reader(const char* abuf, size_t asize, const String& afile_name): 
                   buf(abuf), size(asize), file_name(afile_name), offset(0) {
           }
           
           override size_t read(const char* &abuf, size_t limit) {
                   size_t to_read=min(limit, size-offset);
                   abuf=buf+offset;
                   offset+=to_read;
                   return to_read;
           }
   
           override void seek(uint64_t value) {
                   if(value>(uint64_t)size)
                           throw Exception(IMAGE_FORMAT, &file_name, "seek to %.15g failed: out of buffer (%.15g)", value, size);
                   offset=(size_t)value;
           }
   
           override uint64_t tell() { return offset; }
   
           override uint64_t length() { return size; }
   
 };  };
   
 // GIF  
 struct GIF_Header {  struct Measure_info {
         char       type[3];          // 'GIF'          ushort width;
         char       version[3];          ushort height;
         unsigned char       width[2];          Value** exif;
         unsigned char       height[2];          Value** xmp;
         char       dif;          Charset* xmp_charset;
         char       fonColor;  
         char       nulls;  
 };  
   
 // JPEG  
 struct JFIF_Header {  
         char length[2];               // length of JFIF segment marker  
         char identifier[5];           // JFIF identifier  
         char version[2];              // version  
         char units;                   // units X of Y pixel density  
         char xdensity[2];             // X pixel density  
         char ydensity[2];             // X pixel density  
         char xthumbnails;             // width of thumbnails  
         char ythumbnails;             // height of thumbnails  
         char reserved;                // reserved  
 };  
 struct JPG_Frame {  
         char length[2];                // length of image marker  
         char data;                     // data precision of bits/sample  
         char height[2];                // image height  
         char width[2];                 // image width  
         char numComponents;            // number of color components  
 };  };
   
 //  
   
 inline short bytes_to_int(unsigned char HI, unsigned char LO) {  inline ushort x_endian_to_ushort(uchar b0, uchar b1) {
         return (short)((HI<<8) + LO);          return (ushort)((b1<<8) + b0);
 }  }
   
 void measure_gif(Pool& pool, const String *origin_string,   inline uint x_endian_to_uint(uchar b0, uchar b1, uchar b2, uchar b3) {
                          Measure_reader& reader, int& width, int& height) {          return (uint)(((((b3<<8) + b2)<<8)+b1)<<8)+b0;
   }
   
         unsigned char *buf;  inline ushort endian_to_ushort(bool is_big, const uchar *b/* [2] */) {
         const int head_size=sizeof(GIF_Header);          return is_big ? x_endian_to_ushort(b[1], b[0]) : x_endian_to_ushort(b[0], b[1]);
         if(reader.read(buf, head_size)<head_size)  }
                 PTHROW(0, 0,   
                         origin_string,   
                         "broken GIF header - file size is less then %d bytes", head_size);  
   
         GIF_Header& screenD=*reinterpret_cast<GIF_Header *>(buf);  
         if(strncmp(screenD.type, "GIF", 3)!=0)  
                 PTHROW(0, 0,   
                         origin_string,   
                         "bad image file - GIF signature not found");      
   
         width=bytes_to_int(screenD.width[1], screenD.width[0]);  inline uint endian_to_uint(bool is_big, const uchar *b /* [4] */) {
         height=bytes_to_int(screenD.height[1], screenD.height[0]);          return is_big ? x_endian_to_uint(b[3], b[2], b[1], b[0]) : x_endian_to_uint(b[0], b[1], b[2], b[3]);
 }  }
   
 void measure_jpeg(Pool& pool, const String *origin_string,   
                          Measure_reader& reader, int& width, int& height) {  
         // JFIF format markers  
         const unsigned char SOI=0xD8;  
         const unsigned char EOI=0xD9;  
         const unsigned char APP0=0xE0;  
         const unsigned char SOF0=0xC0;  
         const unsigned char SOF2=0xC2;  
         const unsigned char COM=0xFE;  
   
         unsigned char *screenD_buf;  ///*********************************************** JPEG
         unsigned char *h_buf=0;  
           struct JPG_Segment_head {
         bool flag=false;          uchar marker;
           uchar code;
           uchar length[2];
   };
   /// JPEG frame header
   struct JPG_Size_segment_body {
           char data;              //< data precision of bits/sample
           uchar height[2];        //< image height
           uchar width[2];         //< image width
           char numComponents;     //< number of color components
   };
   
   /// JPEG Exif TIFF Header
   struct JPG_Exif_TIFF_header {
           char byte_align_identifier[2];
           uchar signature[2]; // always 000A [or 0A00]
           uchar first_IFD_offset[4]; // Usually the first IFD starts immediately next to TIFF header, so this offset has value '0x00000008'.
   };
   
   // JPEG Exif IFD start
   struct JPG_Exif_IFD_begin {
           uchar directory_entry_count[2]; // the number of directory entry contains in this IFD
   };
   
   // TTTT ffff NNNNNNNN DDDDDDDD 
   struct JPG_Exif_IFD_entry {
           uchar tag[2]; // Tag number, this shows a kind of data
           uchar format[2]; // data format
           uchar components_count[4]; // number of components
           uchar value_or_offset_to_it[4]; // data value or offset to data value
   };
   
   #define JPG_IFD_TAG_EXIF_OFFSET 0x8769
   
   #define JPG_IFD_TAG_EXIF_GPS_OFFSET 0x8825
   
   #define JPEG_EXIF_DATE_CHARS 20
   
   static Value* parse_IFD_entry_formatted_one_value(bool is_big, ushort format, size_t component_size, const uchar *value) {
           switch(format) {
           case 1: // unsigned byte
                   return new VInt((uchar)value[0]);
           case 3: // unsigned short
                   return new VInt(endian_to_ushort(is_big, value));
           case 4: // unsigned long
                    // 'double' because parser's Int is signed
                   return new VDouble(endian_to_uint(is_big, value));
           case 5: // unsigned rational
                   {
                           uint numerator=endian_to_uint(is_big, value); value+=component_size/2;
                           uint denominator=endian_to_uint(is_big, value);
                           if(!denominator)
                                   return 0;
                           return new VDouble(((double)numerator)/denominator);
                   }
           case 6: // signed byte
                   return new VInt((signed char)value[0]);
           case 8: // signed short
                   return new VInt((signed short)endian_to_ushort(is_big, value));
           case 9: // signed long
                   return new VInt((signed int)endian_to_uint(is_big, value));
           case 10: // signed rational
                   {
                           signed int numerator=(signed int)endian_to_uint(is_big, value); value+=component_size/2;
                           uint denominator=endian_to_uint(is_big, value);
                           if(!denominator)
                                   return 0;
                           return new VDouble(numerator/denominator);
                   }
                   /*
           case 11: // single float
                   @todo
           case 12: // double float
                   @todo
                   */
           };      
                   
         unsigned char *prefix;          return 0;
         const prefix_size=2;  }
         if(reader.read(prefix, prefix_size)<prefix_size)  
                 PTHROW(0, 0,   // date.C
                         origin_string,   tm cstr_to_time_t(char *, const char **);
                         "broken JPEG file - size is less then %d bytes", prefix_size);  
   static Value* parse_IFD_entry_formatted_value(bool is_big, ushort format, size_t component_size, uint components_count, const uchar *value) {
           if(format==2) { // ascii string, exception: the only type with varying size
                   const char* cstr=(const char* )value;
                   size_t length=components_count;
                   // Data format is "YYYY:MM:DD HH:MM:SS"+0x00, total 20bytes
                   if(length==JPEG_EXIF_DATE_CHARS && isdigit((unsigned char)cstr[0]) && cstr[length-1]==0) {
                           char cstr_writable[JPEG_EXIF_DATE_CHARS];
                           strcpy(cstr_writable, cstr);
   
                           try {
                                   tm tmIn=cstr_to_time_t(cstr_writable, 0);
                                   return new VDate(tmIn);
                           }
                           catch(...) { /*ignore bad date times*/ }
                   }
   
                   return new VString(*new String(cstr, String::L_TAINTED));
           }
   
           if(components_count==1)
                   return parse_IFD_entry_formatted_one_value(is_big, format, component_size, value);
   
           VHash* result=new VHash;
           HashStringValue& hash=result->hash();
           for(uint i=0; i<components_count; i++, value+=component_size) {
                   hash.put(
                           String::Body::Format(i),
                           parse_IFD_entry_formatted_one_value(is_big, format, component_size, value));
           }
   
           return result;
   }
   
   static Value* parse_IFD_entry_value(bool is_big, Measure_reader& reader, long tiff_base, JPG_Exif_IFD_entry& entry) {
           size_t format2component_size[]={
                   0, // undefined
                   1, // unsigned byte
                   1, // ascii string
                   2, // unsigned short
                   4, // unsigned long
                   8, // unsigned rational
                   1, // signed byte
                   0, // undefined
                   2, // signed short
                   4, // signed long
                   8, // signed rational
                   /*
                   4, // single float
                   8, // double float
                   */
           };
   
           ushort format=endian_to_ushort(is_big, entry.format);
           if(format>=sizeof(format2component_size)/sizeof(format2component_size[0]))
                   return 0; // format out of range, ignoring
   
           size_t component_size=format2component_size[format];
           if(component_size==0)
                   return 0; // undefined format
   
           // You can get the total data byte length by multiplies 
           // a 'bytes/components' value (see above chart) by number of components stored 'NNNNNNNN' area
           uint components_count=endian_to_uint(is_big, entry.components_count);
           uint value_size=component_size*components_count;
           // If its size is over 4bytes, 'DDDDDDDD' contains the offset to data stored address
           Value* result;
   
           if(value_size<=4)
                   result=parse_IFD_entry_formatted_value(is_big, format, component_size, components_count, entry.value_or_offset_to_it);
           else {
                   uint64_t remembered=reader.tell();
                   {
                           reader.seek(tiff_base+endian_to_uint(is_big, entry.value_or_offset_to_it));
                           const char* value;
                           if(reader.read(value, value_size)<value_size)
                                   return 0;
                           result=parse_IFD_entry_formatted_value(is_big, format, component_size, components_count, (const uchar*)value);
                   }
                   reader.seek(remembered);
           }
   
           return result;
   }
   
   static void parse_IFD(HashStringValue& hash, bool is_big, Measure_reader& reader, long tiff_base, bool gps=false);
   
   static void parse_IFD_entry(HashStringValue& hash, bool is_big, Measure_reader& reader, long tiff_base, JPG_Exif_IFD_entry& entry, bool gps=false) {
           ushort tag=endian_to_ushort(is_big, entry.tag);
   
           if(tag==JPG_IFD_TAG_EXIF_OFFSET || tag==JPG_IFD_TAG_EXIF_GPS_OFFSET){
                   uint64_t remembered=reader.tell();
                   {
                           reader.seek(tiff_base+endian_to_uint(is_big, entry.value_or_offset_to_it));
                           parse_IFD(hash, is_big, reader, tiff_base, (tag==JPG_IFD_TAG_EXIF_GPS_OFFSET)?true:gps);
                   }
                   reader.seek(remembered);
                   return;
           }
   
           if(Value* value=parse_IFD_entry_value(is_big, reader, tiff_base, entry)) {
                   if(const char* name=(gps)?exif_gps_tag_value2name.get(tag):exif_tag_value2name.get(tag))
                           hash.put(name, value);
                   else
                           hash.put(String::Body::Format(tag), value);
           }
   }
   
   static void parse_IFD(HashStringValue& hash, bool is_big, Measure_reader& reader, long tiff_base, bool gps) {
           const char* buf;
           if(reader.read(buf, sizeof(JPG_Exif_IFD_begin))<sizeof(JPG_Exif_IFD_begin))
                   return;
           JPG_Exif_IFD_begin *start=(JPG_Exif_IFD_begin *)buf;
   
           ushort directory_entry_count=endian_to_ushort(is_big, start->directory_entry_count);
           for(int i=0; i<directory_entry_count; i++) {
                   if(reader.read(buf, sizeof(JPG_Exif_IFD_entry))<sizeof(JPG_Exif_IFD_entry))
                           return;
   
                   parse_IFD_entry(hash, is_big, reader, tiff_base, *(JPG_Exif_IFD_entry *)buf, gps);
           }
           // then goes: LLLLLLLL Offset to next IFD [not going there]
   }
   
   static Value* parse_exif(Measure_reader& reader) {
           const char* buf;
   
           uint tiff_base=reader.tell();
           if(reader.read(buf, sizeof(JPG_Exif_TIFF_header))<sizeof(JPG_Exif_TIFF_header))
                   return 0;
   
           JPG_Exif_TIFF_header *head=(JPG_Exif_TIFF_header *)buf;
           bool is_big=head->byte_align_identifier[0]=='M'; // [M]otorola vs [I]ntel
   
           uint first_IFD_offset=endian_to_uint(is_big, head->first_IFD_offset);
           reader.seek(tiff_base+first_IFD_offset);
   
           VHash* vhash=new VHash;
   
           // IFD
           parse_IFD(vhash->hash(), is_big, reader, tiff_base);
   
           return vhash;
   }
   
   static Value* parse_xmp(Measure_reader& reader, ushort xmp_length, Measure_info &info) {
           const char* buf;
           if(reader.read(buf, xmp_length)<xmp_length)
                   return 0;
   
           String::C xmp = Charset::transcode(String::C(pa_strdup(buf, xmp_length), xmp_length), *info.xmp_charset, pa_thread_request().charsets.source());
           return new VString(*new String(xmp, String::L_TAINTED));
   }
   
   static void measure_jpeg(const String& origin_string, Measure_reader& reader, Measure_info &info) {
           // JFIF format markers
           const uchar MARKER=0xFF;
           const uchar CODE_SIZE_A=0xC0;
           const uchar CODE_SIZE_B=0xC1;
           const uchar CODE_SIZE_C=0xC2;
           const uchar CODE_SIZE_D=0xC3;
           const uchar CODE_APP1=0xE1;
   
           const char* buf;
           const size_t prefix_size=2;
           if(reader.read(buf, prefix_size)<prefix_size)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not JPEG file - too small");
           uchar *signature=(uchar *)buf;
                   
         if(((unsigned char *)prefix)[1]!=SOI)           if(!(signature[0]==0xFF && signature[1]==0xD8)) 
                 PTHROW(0, 0,                   throw Exception(IMAGE_FORMAT, &origin_string, "not JPEG file - wrong signature");
                         origin_string,   
                         "broken JPEG file - second byte of header is not 0x%02X", SOI);          while(true) {
                                   uint segment_base=reader.tell()+2/*marker,code*/;
         unsigned char zero=0;                  if(reader.read(buf, sizeof(JPG_Segment_head))<sizeof(JPG_Segment_head))
         unsigned char *marker=&zero;  
   
         do {  
                 while((*marker)!=0xFF)  
                         if(reader.read(marker, sizeof(char))<=0) break;  
                 if(reader.read(marker, sizeof(char))<=0) break;  
                 switch(*marker) {  
                 case EOI:  
                         marker=&zero;  
                         break;                          break;
                 case APP0:                  JPG_Segment_head *head=(JPG_Segment_head *)buf;
                         if(!flag) {  
                                 flag=true;                  // Verify that it's a valid segment.
                                 if(reader.read(screenD_buf, sizeof(JFIF_Header)) < sizeof(JFIF_Header))                  if(head->marker!=MARKER)
                           throw Exception(IMAGE_FORMAT, &origin_string, "not JPEG file - marker not found");
   
                   ushort segment_length=endian_to_ushort(true, head->length);
   
                   switch(head->code) {
                   // http://dev.exiv2.org/projects/exiv2/wiki/The_Metadata_in_JPEG_files
                   case CODE_APP1:
                           {
                                   const size_t EXIF_SIG_LEN=6; // Exif\0\0
                                   const size_t XMP_SIG_LEN=29; // http://ns.adobe.com/xap/1.0/\0
   
                                   if(segment_length<EXIF_SIG_LEN+2 || reader.read(buf, EXIF_SIG_LEN)<EXIF_SIG_LEN)
                                         break;                                          break;
                                 JFIF_Header& screenD=*reinterpret_cast<JFIF_Header *>(screenD_buf);                                  if(memcmp(buf, "Exif\0\0", EXIF_SIG_LEN)==0){
                                 if((bytes_to_int(screenD.length[0], screenD.length[1]) < 16) ||                                          if(info.exif && !*info.exif) // backward compatibility: using first segment
                                         strcasecmp(screenD.identifier, "JFIF")) flag=false;                                                  *info.exif=parse_exif(reader);
                                           break;
                                   }
   
                                   if(memcmp(buf, "http:/", EXIF_SIG_LEN))
                                           break;
                                   if(segment_length<XMP_SIG_LEN+2 || reader.read(buf, XMP_SIG_LEN-EXIF_SIG_LEN)<XMP_SIG_LEN-EXIF_SIG_LEN)
                                           break;
                                   if(memcmp(buf, "/ns.adobe.com/xap/1.0/\0", XMP_SIG_LEN-EXIF_SIG_LEN)==0){
                                           if(info.xmp && !*info.xmp) // backward compatibility: using first segment
                                                   *info.xmp=parse_xmp(reader, segment_length - XMP_SIG_LEN - 2 /* segment_length */, info);
                                   }
   
                         }                          }
                         break;                          break;
                 case SOF0:  
                 case SOF2:                  case CODE_SIZE_A:
                         if(reader.read(h_buf, sizeof(JPG_Frame))<sizeof(JPG_Frame))                  case CODE_SIZE_B:
                                 flag=false;                  case CODE_SIZE_C:
                         break;                  case CODE_SIZE_D:
                 default: break;                          {
                                   // Segments that contain size info
                                   if(reader.read(buf, sizeof(JPG_Size_segment_body))<sizeof(JPG_Size_segment_body))
                                           throw Exception(IMAGE_FORMAT, &origin_string, "not JPEG file - can not fully read Size segment");
                                   JPG_Size_segment_body *body=(JPG_Size_segment_body *)buf;
                                   
                                   info.width=endian_to_ushort(true, body->width);
                                   info.height=endian_to_ushort(true, body->height);
                           }
                           return;
                   };
   
                   reader.seek(segment_base + segment_length);
           }
   
           throw Exception(IMAGE_FORMAT, &origin_string, "broken JPEG file - size frame not found");
   }
   
   ///*********************************************** TIFF
   
   static bool parse_tiff_IFD(bool is_big, Measure_reader& reader, Measure_info &info) {
           const char* buf;
           if(reader.read(buf, sizeof(JPG_Exif_IFD_begin))<sizeof(JPG_Exif_IFD_begin))
                   return false;
           JPG_Exif_IFD_begin *start=(JPG_Exif_IFD_begin *)buf;
   
           ushort directory_entry_count=endian_to_ushort(is_big, start->directory_entry_count);
           for(int i=0; i<directory_entry_count; i++) {
                   if(reader.read(buf, sizeof(JPG_Exif_IFD_entry))<sizeof(JPG_Exif_IFD_entry))
                           return false;
   
                   JPG_Exif_IFD_entry *entry=(JPG_Exif_IFD_entry *)buf;
                   ushort entry_tag=endian_to_ushort(is_big, entry->tag);
   
                   if(entry_tag == 256 || entry_tag == 257){
                           ushort entry_format=endian_to_ushort(is_big, entry->format);
                           if(entry_format != 3 && entry_format != 4 || endian_to_uint(is_big, entry->components_count) != 1)
                                   return false;
                           uint value = (entry_format == 3) ? endian_to_ushort(is_big, entry->value_or_offset_to_it) : endian_to_uint(is_big, entry->value_or_offset_to_it);
                           (entry_tag == 256) ? info.width=value : info.height=value;
                           if(info.width && info.height)
                                   return true;
                 }                  }
         } while(*marker!=EOI);          }
           
         if(flag && h_buf) {          return false;
                 JPG_Frame& h=*reinterpret_cast<JPG_Frame *>(h_buf);          // then goes: LLLLLLLL Offset to next IFD [not going there]
                 width=bytes_to_int(h.width[0], h.width[1]);  }
                 height=bytes_to_int(h.height[0], h.height[1]);  
         } else  static void measure_tiff(const String& origin_string, Measure_reader& reader, Measure_info &info) {
                 PTHROW(0, 0,          const char* buf;
                         origin_string,  
                         "broken JPEG file - APP0 frame not found");                               if(reader.read(buf, sizeof(JPG_Exif_TIFF_header))<sizeof(JPG_Exif_TIFF_header))
                   throw Exception(IMAGE_FORMAT, &origin_string, "not TIFF file - too small");
   
           JPG_Exif_TIFF_header *head=(JPG_Exif_TIFF_header *)buf;
   
           if(strncmp(head->byte_align_identifier, "II", 2)!=0 && strncmp(head->byte_align_identifier, "MM", 2)!=0)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not TIFF file - wrong signature");
   
           bool is_big=head->byte_align_identifier[0]=='M'; // [M]otorola vs [I]ntel
   
           if(endian_to_ushort(is_big, head->signature) != 42)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not TIFF file - wrong signature");
   
           reader.seek(endian_to_uint(is_big, head->first_IFD_offset));
           if(!parse_tiff_IFD(is_big, reader, info))
                   throw Exception(IMAGE_FORMAT, &origin_string, "broken TIFF file - size field entry not found");
   }
   
   
   ///*********************************************** GIF
   
   struct GIF_Header {
           char    signature[3];   // 'GIF'
           char    version[3];
           uchar   width[2];
           uchar   height[2];
           char    dif;
           char    fonColor;
           char    nulls;
   };
   
   static void measure_gif(const String& origin_string, Measure_reader& reader, ushort& width, ushort& height) {
   
           const char* buf;
           const size_t head_size=sizeof(GIF_Header);
           if(reader.read(buf, head_size)<head_size)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not GIF file - too small");
           GIF_Header *head=(GIF_Header *)buf;
   
           if(strncmp(head->signature, "GIF", 3)!=0)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not GIF file - wrong signature");
   
           width=endian_to_ushort(false, head->width);
           height=endian_to_ushort(false, head->height);
   }
   
   
   ///*********************************************** PNG
   
   struct PNG_Header {
           char    dummy[12];
           char    signature[4];   //< must be "IHDR"
           uchar   high_width[2];  //< image width high bytes [we ignore for now]
           uchar   width[2];       //< image width low bytes
           uchar   high_height[2]; //< image height high bytes [we ignore for now]
           uchar   height[4];      //< image height
   };
   
   static void measure_png(const String& origin_string, Measure_reader& reader, ushort& width, ushort& height) {
   
           const char* buf;
           const size_t head_size=sizeof(PNG_Header);
           if(reader.read(buf, head_size)<head_size)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not PNG file - too small");
           PNG_Header *head=(PNG_Header *)buf;
   
           if(strncmp(head->signature, "IHDR", 4)!=0)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not PNG file - wrong signature");
   
           width=endian_to_ushort(true, head->width);
           height=endian_to_ushort(true, head->height);
   }
   
   
   ///*********************************************** BMP
   
   struct BMP_Header {
           char    signature[2];   // 'BM'
           uchar   file_size[4];
           uchar   reserved[4];
           uchar   bitmap_offset[4];
           uchar   header_size[4];
           uchar   width[2];
           uchar   high_width[2];  //< image width high bytes [we ignore for now]
           uchar   height[2];
           uchar   high_height[2]; //< image height high bytes [we ignore for now]
   };
   
   static void measure_bmp(const String& origin_string, Measure_reader& reader, ushort& width, ushort& height) {
   
           const char* buf;
           const size_t head_size=sizeof(BMP_Header);
           if(reader.read(buf, head_size)<head_size)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not BMP file - too small");
           BMP_Header *head=(BMP_Header *)buf;
   
           if(strncmp(head->signature, "BM", 2)!=0)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not BMP file - wrong signature");
   
           if((uint)reader.length() != endian_to_uint(false, head->file_size))
                   throw Exception(IMAGE_FORMAT, &origin_string, "not BMP file - length header and file size do not match");
   
           width=endian_to_ushort(false, head->width);
           height=endian_to_ushort(false, head->height);
   }
   
   
   ///*********************************************** WEBP
   
   struct WEBP_Header {
           char signature_riff[4]; // 'RIFF'
           uchar file_size[4];
           char signature[4];      // 'WEBP'
           char format[4];         // 'VP8 ' or 'VP8L' or 'VP8X'
   };
   
   struct WEBP_VP8_Chunk {
           uchar size[4];
           char tag[3];
           uchar signature[3];    // 0x9D 0x01 0x2A
           uchar width[2];        // 14 bits each
           uchar height[2];       // 14 bits each
   };
   
   struct WEBP_VP8L_Chunk {
           uchar size[4];
           char signature;        // 0x2F
           uchar width_height[4]; // 14 bits each
   };
   
   struct WEBP_X_Chunk {
           uchar size[4];
           char reserved[4];
           uchar width[3];
           uchar height[3];
   };
   
   static void measure_webp(const String& origin_string, Measure_reader& reader, ushort& width, ushort& height) {
           const char* buf;
   
           if(reader.read(buf, sizeof(WEBP_Header))<sizeof(WEBP_Header))
                   throw Exception(IMAGE_FORMAT, &origin_string, "not WEBP file - too small");
   
           WEBP_Header *head=(WEBP_Header *)buf;
   
           if(strncmp(head->signature_riff, "RIFF", 4)!=0 || strncmp(head->signature, "WEBP", 4)!=0)
                   throw Exception(IMAGE_FORMAT, &origin_string, "not WEBP file - wrong signature");
   
           if(strncmp(head->format, "VP8 ", 4)==0){
                   if(reader.read(buf, sizeof(WEBP_VP8_Chunk))<sizeof(WEBP_VP8_Chunk))
                           throw Exception(IMAGE_FORMAT, &origin_string, "broken WEBP file - too small VP8 chunk");
   
                   WEBP_VP8_Chunk *chunk=(WEBP_VP8_Chunk *)buf;
                   if (chunk->signature[0] != 0x9D || chunk->signature[1] != 0x01 || chunk->signature[2] != 0x2A)
                           throw Exception(IMAGE_FORMAT, &origin_string, "broken WEBP file - wrong VP8 chunk signature");
   
                   width=endian_to_ushort(false, chunk->width) & 0x3FFF;
                   height=endian_to_ushort(false, chunk->height) & 0x3FFF;
           } else if(strncmp(head->format, "VP8L", 4)==0){
                   if(reader.read(buf, sizeof(WEBP_VP8L_Chunk))<sizeof(WEBP_VP8L_Chunk))
                           throw Exception(IMAGE_FORMAT, &origin_string, "broken WEBP file - too small VP8L chunk");
   
                   WEBP_VP8L_Chunk *chunk=(WEBP_VP8L_Chunk *)buf;
                   if(chunk->signature != 0x2F)
                           throw Exception(IMAGE_FORMAT, &origin_string, "broken WEBP file - wrong VP8L chunk signature");
   
                   uint wh=endian_to_uint(false, chunk->width_height);
                   width=(wh & 0x3FFF) + 1;
                   height=((wh >> 14) & 0x3FFF) + 1;
           } else if (strncmp(head->format, "VP8X", 4)==0){
                   if(reader.read(buf, sizeof(WEBP_X_Chunk))<sizeof(WEBP_X_Chunk))
                           throw Exception(IMAGE_FORMAT, &origin_string, "broken WEBP file - too small VP8X chunk");
   
                   WEBP_X_Chunk *chunk=(WEBP_X_Chunk *)buf;
   
                   width=endian_to_ushort(false, chunk->width) + 1;   // we ignore third byte to simplify code
                   height=endian_to_ushort(false, chunk->height) + 1; // we ignore third byte to simplify code
           } else throw Exception(IMAGE_FORMAT, &origin_string, "broken WEBP file - invalid chunk signature");
   }
   
   
   ///*********************************************** MP4
   
   struct MP4_Header {
           uchar size[4];
           char signature[4];   // 'ftyp' in first chunk
   };
   
   struct MP4_ExtSize {
           uchar high[4];
           uchar low[4];
   };
   
   struct MP4_Tkhd {
           uchar width[4];
           uchar height[4];
   };
   
   static bool measure_mp4(const String& origin_string, Measure_reader& reader, ushort& width, ushort& height, uint64_t anext, const char* lastTkhd=NULL) {
           for(bool first=anext==0;;){
                   const char* buf;
                   uint64_t next=reader.tell();
   
                   if(reader.read(buf, sizeof(MP4_Header))<sizeof(MP4_Header))
                           throw Exception(IMAGE_FORMAT, &origin_string, first ? "not MP4 file - too small" : "broken MP4 file - truncated chunk header");
   
                   MP4_Header *head=(MP4_Header *)buf;
                   uint64_t size=endian_to_uint(true, head->size);
   
                   if(size==1){
                           if(reader.read(buf, sizeof(MP4_ExtSize))<sizeof(MP4_ExtSize))
                                   throw Exception(IMAGE_FORMAT, &origin_string, "broken MP4 file - truncated chunk extended size header");
                           MP4_ExtSize *ext_size=(MP4_ExtSize *)buf;
                           size=((uint64_t)endian_to_uint(true, ext_size->high) << 32) + endian_to_uint(true, ext_size->low);
                   }
                   next+=size;
   
                   if(first){
                           if(strncmp(head->signature, "ftyp", 4)!=0)
                                   throw Exception(IMAGE_FORMAT, &origin_string, "not MP4 file - wrong signature");
                           first=false;
                           anext=reader.length(); // to avoid reading beyond EOF
                   } else if(strncmp(head->signature, "moov", 4)==0 || strncmp(head->signature, "mdia", 4)==0 || strncmp(head->signature, "trak", 4)==0) {
                           if(measure_mp4(origin_string, reader, width, height, next, lastTkhd))
                                   return true;
                   } else if(strncmp(head->signature, "tkhd", 4)==0) {
                           if(size>8){
                                   reader.seek(next-8);
                                   if(reader.read(lastTkhd, sizeof(MP4_Tkhd))<sizeof(MP4_Tkhd))
                                           throw Exception(IMAGE_FORMAT, &origin_string, "broken MP4 file - bad tkhd chunk");
                           }
                   } else if (strncmp(head->signature, "hdlr", 4)==0) {
                           if(size>12){
                                   const char* hdlr;
                                   if(reader.read(hdlr, 12)<12)
                                           throw Exception(IMAGE_FORMAT, &origin_string, "broken MP4 file - bad hdlr chunk");
                                   if(lastTkhd && strncmp(hdlr+8, "vide", 4)==0) {
                                           MP4_Tkhd *tkhd=(MP4_Tkhd *)lastTkhd;
                                           width=endian_to_ushort(true, tkhd->width);
                                           height=endian_to_ushort(true, tkhd->height);
                                           return true;
                                   }
                           }
                   }
                   if(anext && next>=anext)
                           break;
                   reader.seek(next);
           }
           return false;
   }
   
   static void measure_mp4(const String& origin_string, Measure_reader& reader, ushort& width, ushort& height) {
           if(!measure_mp4(origin_string, reader, width, height, 0))
                   throw Exception(IMAGE_FORMAT, &origin_string, "unsupported MP4 file - size not found");
 }  }
   
 // measure center  ///*********************************************** measure center
   
 void measure(Pool& pool, const String& file_name,   static void measure(const String& file_name, Measure_reader& reader, Measure_info &info) {
                          Measure_reader& reader, int& width, int& height) {          const char* file_name_cstr=file_name.taint_cstr(String::L_FILE_SPEC);
         if(const char *cext=strrchr(file_name.cstr(), '.')) {          if(const char* cext=strrchr(file_name_cstr, '.')) {
                 cext++;                  cext++;
                 if(strcasecmp(cext, "GIF")==0)                  if(strcasecmp(cext, "GIF")==0)
                         measure_gif(pool, &file_name, reader, width, height);                          measure_gif(file_name, reader, info.width, info.height);
                 else if(strcasecmp(cext, "JPG")==0 || strcasecmp(cext, "JPEG")==0)                   else if(strcasecmp(cext, "JPG")==0 || strcasecmp(cext, "JPEG")==0)
                         measure_jpeg(pool, &file_name, reader, width, height);                          measure_jpeg(file_name, reader, info);
                   else if(strcasecmp(cext, "PNG")==0)
                           measure_png(file_name, reader, info.width, info.height);
                   else if(strcasecmp(cext, "BMP")==0)
                           measure_bmp(file_name, reader, info.width, info.height);
                   else if(strcasecmp(cext, "WEBP")==0)
                           measure_webp(file_name, reader, info.width, info.height);
                   else if(strcasecmp(cext, "TIF")==0 || strcasecmp(cext, "TIFF")==0)
                           measure_tiff(file_name, reader, info);
                   else if(strcasecmp(cext, "MP4")==0 || strcasecmp(cext, "MOV")==0)
                           measure_mp4(file_name, reader, info.width, info.height);
                 else                  else
                         PTHROW(0, 0,                           throw Exception(IMAGE_FORMAT, &file_name, "unhandled image file name extension '%s'", cext);
                                 &file_name,   
                                 "unhandled image file name extension '%s'", cext);  
         } else          } else
                 PTHROW(0, 0,                   throw Exception(IMAGE_FORMAT, &file_name, "can not determine image type - no file name extension");
                         &file_name,   
                         "can not determine image type - no file name extension");  
 }  }
   
 // read from somewhere  // methods
   
 struct Read_mem_info {  static void file_measure_action(struct stat& /*finfo*/, int f, const String& file_spec, void *context) {
         unsigned char *ptr;          Measure_file_reader reader(f, file_spec);
         unsigned char *eof;          measure(file_spec, reader, *static_cast<Measure_info *>(context));
 };  
 static size_t read_mem(void*& buf, size_t limit, void *info) {  
         Read_mem_info& rmi=*static_cast<Read_mem_info *>(info);  
         buf=rmi.ptr;  
         size_t read_size=min(limit, (size_t)(rmi.eof-rmi.ptr));  
         rmi.ptr+=read_size;  
         return read_size;  
 }  }
   
 struct Read_disk_info {  static void _measure(Request& r, MethodParams& params) {
         const String *file_spec;          Value& data=params.as_no_junction(0, "data must not be code");
         size_t offset;  
 };          Value* exif=0;
 static size_t read_disk(void*& buf, size_t limit, void *info) {          Value* xmp=0;
         Read_disk_info& rdi=*static_cast<Read_disk_info *>(info);          Measure_info info={ 0, 0, 0, 0, &pa_UTF8_charset };
         Pool& pool=rdi.file_spec->pool();  
           if(params.count()>1)
         size_t read_size;                  if(HashStringValue* options=params.as_hash(1, "methods options")) {
         file_read(pool, *rdi.file_spec,                           int valid_options=0;
                            buf, read_size,                           for(HashStringValue::Iterator i(*options); i; i.next() ){
                            false/*as_text*/,                                   String::Body key=i.key();
                            true/*fail_on_read_problem*/,                                   Value* value=i.value();
                            rdi.offset, limit);                                  if(key == "exif") {
                                           if(r.process(*value).as_bool())
                                                   info.exif=&exif;
                                           valid_options++;
                                   }
                                   if(key == "xmp") {
                                           if(r.process(*value).as_bool())
                                                   info.xmp=&xmp;
                                           valid_options++;
                                   }
                                   if(key == "xmp-charset") {
                                           info.xmp_charset=&pa_charsets.get(value->as_string());
                                           valid_options++;
                                   }
                           }
                           if(valid_options!=options->count())
                                   throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
                   }
   
           const String* file_name;
   
           if(file_name=data.get_string()) {
                   file_read_action_under_lock(r.full_disk_path(*file_name), "measure", file_measure_action, &info);
           } else {
                   VFile* vfile=data.as_vfile(String::L_AS_IS);
                   file_name=&vfile->fields().get(name_name)->as_string();
                   Measure_buf_reader reader(vfile->value_ptr(), vfile->value_size(), *file_name);
                   measure(*file_name, reader, info);
           }
   
         rdi.offset+=read_size;          GET_SELF(r, VImage).set(file_name, info.width, info.height, 0, exif, xmp);
         return read_size;  
 }  }
   
 // methods  static void append_attrib_pair(String &tag, String::Body key, Value* value){
           // skip border attribute with empty value
           if(key=="border" && !value->is_defined())
                   return;
   
           // src="a.gif" width="123" ismap[=-1]
           tag << " " << key;
           if(value->is_string() || value->as_int()>=0)
                   tag << "=\"" << value->as_string() << "\"";
   }
   
   static void _html(Request& r, MethodParams& params) {
           String tag;
           tag << "<img";
   
           const HashStringValue& fields=GET_SELF(r, VImage).fields();
           HashStringValue* attribs=0;
   
           if(params.count()) {
                   // for backward compatibility: someday was ^html{}
                   Value& vattribs=r.process(params[0]);
                   if(!vattribs.is_string()) { // allow empty
                           if((attribs=vattribs.get_hash())) {
                                   for(HashStringValue::Iterator i(*attribs); i; i.next() )
                                           append_attrib_pair(tag, i.key(), i.value());
                           } else
                                   throw Exception(PARSER_RUNTIME, 0, "attributes must be hash");
                   }
           }
   
           for(HashStringValue::Iterator i(fields); i; i.next() ){
                   String::Body key=i.key();
                   // skip user-specified attributes
                   if(attribs && attribs->get(key))
                           continue;
                   // allow only html attributes (to exclude exif, line-*)
                   if(key=="src" || key=="width" || key=="height" || key=="border")
                           append_attrib_pair(tag, key, i.value());
           }
   
           tag << " />";
           r.write(tag);
   }
   
 /// ^image:measure[DATA]  /// @test wrap FILE to auto-object
 static void _measure(Request& r, const String& method_name, Array *params) {  static gdImage* load(Request& r, const String& file_name){
         Pool& pool=r.pool();          const char* file_name_cstr=r.full_disk_path(file_name).taint_cstr(String::L_FILE_SPEC);
           if(FILE *f=pa_fopen(file_name_cstr, "rb")) {
         Value& data=*static_cast<Value *>(params->get(0));                  gdImage* image=new gdImage;
         // forcing [this body type]                  bool ok=image->CreateFromGif(f);
         r.fail_if_junction_(true, data, method_name, "data must not be code");                  fclose(f);
                   if(!ok)
         void *info; Measure_reader::Func read_func;                           throw Exception(IMAGE_FORMAT, &file_name, "is not in GIF format");
         Read_mem_info read_mem_info;                  return image;
         Read_disk_info read_disk_info;  
         const String *file_name;  
         if(data.is_string()) {  
                 file_name=data.get_string();  
                 read_disk_info.file_spec=&r.absolute(*file_name);  
                 read_disk_info.offset=0;  
                 info=&read_disk_info; read_func=read_disk;  
         } else {          } else {
                 const VFile& vfile=*data.as_vfile();                  throw Exception("file.missing", 0, "can not open '%s'", file_name_cstr);
                 file_name=&static_cast<Value *>(vfile.fields().get(*name_name))->as_string();  
                 read_mem_info.ptr=(unsigned char *)vfile.value_ptr();  
                 read_mem_info.eof=read_mem_info.ptr+vfile.value_size();  
                 info=&read_mem_info; read_func=read_mem;  
         }          }
   }
   
   
         Measure_reader reader(read_func, info);  static void _load(Request& r, MethodParams& params) {
         int width, height;          const String& file_name=params.as_string(0, FILE_NAME_MUST_NOT_BE_CODE);
         measure(pool, *file_name, reader, width, height);  
   
         static_cast<VImage *>(r.self)->set(*file_name, width, height);          gdImage* image=load(r, file_name);
           GET_SELF(r, VImage).set(&file_name, image->SX(), image->SY(), image);
 }  }
   
 struct Attrib_info {  static void _create(Request& r, MethodParams& params) {
         String *tag;          int width=params.as_int(0, "width must be int", r);
         Hash *skip;          int height=params.as_int(1, "height must be int", r);
 };          int bgcolor_value=0xffFFff;
 static void append_attrib_pair(const Hash::Key& key, Hash::Val *val, void *info) {          if(params.count()>2)
         Attrib_info& ai=*static_cast<Attrib_info *>(info);                  bgcolor_value=params.as_int(2, "color must be int", r);
           gdImage* image=new gdImage;
           image->Create(width, height);
           image->FilledRectangle(0, 0, width-1, height-1, image->Color(bgcolor_value));
           GET_SELF(r, VImage).set(0, width, height, image);
   }
   
         if(ai.skip && ai.skip->get(key))  static void _gif(Request& r, MethodParams& params) {
                 return;          gdImage& image=GET_SELF(r, VImage).image();
   
         Value& value=*static_cast<Value *>(val);          const String *file_name=params.count()>0?&params.as_string(0, FILE_NAME_MUST_BE_STRING):0;
         // src="a.gif" width=123 ismap[=-1]  
         *ai.tag << " " << key;  
         if(value.is_string() || value.as_double()>=0) {  
                 *ai.tag << "=";  
                 if(value.is_string())  
                         *ai.tag << "\"";  
                 *ai.tag << value.as_string();  
                 if(value.is_string())  
                         *ai.tag << "\"";  
         }  
 }  
 /// ^image.html[]  
 /// ^image.html[hash]  
 static void _html(Request& r, const String& method_name, Array *params) {  
         Pool& pool=r.pool();  
   
         String tag(pool);          gdBuf buf=image.Gif();
         tag << "<img";          
           VFile& vfile=*new VFile;
   
           vfile.set_binary(false/*not tainted*/, (const char *)buf.ptr, buf.size, file_name, new VString(*new String("image/gif")));
   
           r.write(vfile);
   }
   
   static void _line(Request& r, MethodParams& params) {
           gdImage& image=GET_SELF(r, VImage).image();
   
           image.Line(
                   params.as_int(0, "x0 must be int", r), 
                   params.as_int(1, "y0 must be int", r), 
                   params.as_int(2, "x1 must be int", r), 
                   params.as_int(3, "y1 must be int", r), 
                   image.Color(params.as_int(4, "color must be int", r)));
   }
   
   static void _fill(Request& r, MethodParams& params) {
           gdImage& image=GET_SELF(r, VImage).image();
   
           image.Fill(
                   params.as_int(0, "x must be int", r), 
                   params.as_int(1, "y must be int", r), 
                   image.Color(params.as_int(2, "color must be int", r)));
   }
   
   static void _rectangle(Request& r, MethodParams& params) {
           gdImage& image=GET_SELF(r, VImage).image();
   
           image.Rectangle(
                   params.as_int(0, "x0 must be int", r), 
                   params.as_int(1, "y0 must be int", r), 
                   params.as_int(2, "x1 must be int", r), 
                   params.as_int(3, "y1 must be int", r), 
                   image.Color(params.as_int(4, "color must be int", r)));
   }
   
   static void _bar(Request& r, MethodParams& params) {
           gdImage& image=GET_SELF(r, VImage).image();
   
           image.FilledRectangle(
                   params.as_int(0, "x0 must be int", r), 
                   params.as_int(1, "y0 must be int", r), 
                   params.as_int(2, "x1 must be int", r), 
                   params.as_int(3, "y1 must be int", r), 
                   image.Color(params.as_int(4, "color must be int", r)));
   }
   
   #ifndef DOXYGEN
   static void add_point(Table::element_type row, gdImage::Point **p) {
           if(row->count()!=2)
                   throw Exception(0, 0, "coordinates table must contain two columns: x and y values");
           (**p).x=row->get(0)->as_int();
           (**p).y=row->get(1)->as_int();
           (*p)++;
   }
   #endif
   #ifndef DOXYGEN
   static void add_point(int x, int y, gdImage::Point **p) {
           (**p).x=x;
           (**p).y=y;
           (*p)++;
   }
   #endif
   static void _replace(Request& r, MethodParams& params) {
           int src_color=params.as_int(0, "src color must be int", r);
           int dest_color=params.as_int(1, "dest color must be int", r);
   
           gdImage& image=GET_SELF(r, VImage).image();
   
           gdImage::Point* all_p=0;
           size_t count=0;
           if(params.count() == 3){
                   Table* table=params.as_table(2, "coordinates");
                   count=table->count();
                   all_p=new(PointerFreeGC) gdImage::Point[count];
                   gdImage::Point* add_p=all_p;
                   table->for_each(add_point, &add_p);
           } else {
                   int max_x=image.SX()-1;
                   int max_y=image.SY()-1;
                   if(max_x > 0 && max_y > 0){
                           count=4;
                           all_p=new(PointerFreeGC) gdImage::Point[count];
                           gdImage::Point* add_p=all_p;
                           add_point(0, 0, &add_p);
                           add_point(max_x, 0, &add_p);
                           add_point(max_x, max_y, &add_p);
                           add_point(0, max_y, &add_p);
                   }
           }
   
           if(count)
                   image.FilledPolygonReplaceColor(all_p, count, image.Color(src_color), image.Color(dest_color));
   }
   
   static void _polyline(Request& r, MethodParams& params) {
           gdImage& image=GET_SELF(r, VImage).image();
   
           Table* table=params.as_table(1, "coordinates");
   
           gdImage::Point* all_p=new(PointerFreeGC) gdImage::Point[table->count()];
           gdImage::Point *add_p=all_p;    
           table->for_each(add_point, &add_p);
           image.Polygon(all_p, table->count(), 
                   image.Color(params.as_int(0, "color must be int", r)),
                   false/*not closed*/);
   }
   
   static void _polygon(Request& r, MethodParams& params) {
           gdImage& image=GET_SELF(r, VImage).image();
   
           Table* table=(Table*)params.as_table(1, "coordinates");
   
           gdImage::Point* all_p=new(PointerFreeGC) gdImage::Point[table->count()];
           gdImage::Point *add_p=all_p;    
           table->for_each(add_point, &add_p);
           image.Polygon(all_p, table->count(), 
                   image.Color(params.as_int(0, "color must be int", r)));
   }
   
   static void _polybar(Request& r, MethodParams& params) {
           gdImage& image=GET_SELF(r, VImage).image();
   
           Table* table=(Table*)params.as_table(1, "coordinates");
   
           gdImage::Point* all_p=new(PointerFreeGC) gdImage::Point[table->count()];
           gdImage::Point *add_p=all_p;    
           table->for_each(add_point, &add_p);
           image.FilledPolygon(all_p, table->count(), 
                   image.Color(params.as_int(0, "color must be int", r)));
   }
   
   // font
   
   #define Y(y)(y+index*height)
   
   // Font class
   
   Font::Font(Charset& asource_charset, const String& aalphabet, gdImage* aifont, int aheight, int amonospace, int aspacebarspace, int aletterspacing):
           letterspacing(aletterspacing),
           height(aheight),
           monospace(amonospace),
           spacebarspace(aspacebarspace),
           ifont(aifont),
           alphabet(aalphabet),
           fsource_charset(asource_charset){
   
           if(fsource_charset.isUTF8()){
                   size_t index=0;
                   for(UTF8_string_iterator i(alphabet); i.has_next(); )
                           fletter2index.put_dont_replace(i.next(), index++);
           }
   }
   
   /* ******************************** char ********************************** */
   
   size_t Font::index_of(char ch) {
           if(ch==' ') return STRING_NOT_FOUND;
           return alphabet.pos(ch);
   }
   
   size_t Font::index_of(XMLCh ch) {
           if(ch==' ') return STRING_NOT_FOUND;
           return fletter2index.get(ch);
   }
   
   int Font::index_width(size_t index) {
           if(index==STRING_NOT_FOUND)
                   return spacebarspace;
           int tr=ifont->GetTransparent();
           for(int x=ifont->SX()-1; x>=0; x--) {
                   for(int y=0; y<height; y++)
                           if(ifont->GetPixel(x, Y(y))!=tr) 
                                   return x+1;
           }
           return 0;
   }
   
   void Font::index_display(gdImage& image, int x, int y, size_t index){
           if(index!=STRING_NOT_FOUND) 
                   ifont->Copy(image, x, y, 0, Y(0), index_width(index), height);
   }
   
   /* ******************************** string ********************************** */
   
   int Font::step_width(int index) {
           return letterspacing + (monospace ? monospace : index_width(index));
   }
   
   // counts trailing letter_spacing, consider this OK. useful for contiuations
   int Font::string_width(const String& s){
           const char* cstr=s.cstr();
           int result=0;
   
           if(fsource_charset.isUTF8()){
                   for(UTF8_string_iterator i(s); i.has_next(); )
                           result+=step_width(index_of(i.next()));
           } else {
                   for(const char* current=cstr; *current; current++)
                           result+=step_width(index_of(*current));
           }
   
           return result;
   }
   
   void Font::string_display(gdImage& image, int x, int y, const String& s){
           const char* cstr=s.cstr();
   
           if(fsource_charset.isUTF8()){
                   for(UTF8_string_iterator i(s); i.has_next(); ){
                           size_t index=index_of(i.next());
                           index_display(image, x, y, index);
                           x+=step_width(index);
                   }
           } else {
                   for(const char* current=cstr; *current; current++) {
                           size_t index=index_of(*current);
                           index_display(image, x, y, index);
                           x+=step_width(index);
                   }
           }
   }
   
   //
   
   
   static void _font(Request& r, MethodParams& params) {
           const String& alphabet=params.as_string(0, "alphabet must not be code");
           size_t alphabet_length=alphabet.length(r.charsets.source());
           if(!alphabet_length)
                   throw Exception(PARSER_RUNTIME, 0, "alphabet must not be empty");
   
           gdImage* image=load(r, params.as_string(1, FILE_NAME_MUST_NOT_BE_CODE));
   
           int spacebar_width=image->SX();
           int monospace_width=0; // proportional
           int letter_spacing=1;
           if(params.count()>2){
                   if(HashStringValue* options=params[2].get_hash()){
                           // third option is hash
                           if(params.count()>3)
                                   throw Exception(PARSER_RUNTIME, 0, "too many params were specified");
                           int valid_options=0;
                           if(Value* vspacebar_width=options->get(spacebar_width_name)){
                                   valid_options++;
                                   spacebar_width=r.process(*vspacebar_width).as_int();
                           }
                           if(Value* vmonospace_width=options->get(monospace_width_name)){
                                   valid_options++;
                                   monospace_width=r.process(*vmonospace_width).as_int();
                                   if(!monospace_width)
                                           monospace_width=image->SX();
                           }
                           if(Value* vletter_spacing=options->get(letter_spacing_name)){
                                   valid_options++;
                                   letter_spacing=r.process(*vletter_spacing).as_int();
                           }
                           if(valid_options!=options->count())
                                   throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
                   } else {
                           // backward
                           spacebar_width=params.as_int(2, "param must be int or hash", r);
                           if(params.count()>3) {
                                   monospace_width=params.as_int(3, "monospace_width must be int", r);
                                   if(!monospace_width)
                                           monospace_width=image->SX();
                           }
                   }
           }
   
           if(int remainder=image->SY() % alphabet_length)
                   throw Exception(PARSER_RUNTIME, 0, "font-file height(%d) not divisable by alphabet size(%d), remainder=%d", image->SY(), alphabet_length, remainder);
           
           GET_SELF(r, VImage).set_font(new Font(r.charsets.source(), alphabet, image, image->SY() / alphabet_length, monospace_width, spacebar_width, letter_spacing));
   }
   
   static void _text(Request& r, MethodParams& params) {
           int x=params.as_int(0, "x must be int", r);
           int y=params.as_int(1, "y must be int", r);
           const String& s=params.as_string(2, "text must not be code");
   
         Hash& fields=static_cast<VImage *>(r.self)->fields();          VImage& vimage=GET_SELF(r, VImage);
         Hash *temporary=0;          vimage.font().string_display(vimage.image(), x, y, s);
   }
   
   static void _length(Request& r, MethodParams& params) {
           const String& s=params.as_string(0, "text must not be code");
   
           VImage& vimage=GET_SELF(r, VImage);
           r.write(*new VInt(vimage.font().string_width(s)));
   }
   
   static void _arc(Request& r, MethodParams& params) {
           gdImage& image=GET_SELF(r, VImage).image();
   
           image.Arc(
                   params.as_int(0, "center_x must be int", r), 
                   params.as_int(1, "center_y must be int", r), 
                   params.as_int(2, "width must be int", r), 
                   params.as_int(3, "height must be int", r), 
                   params.as_int(4, "start degrees must be int", r), 
                   params.as_int(5, "end degrees must be int", r), 
                   image.Color(params.as_int(6, "cx must be int", r)));
   }
   
   static void _sector(Request& r, MethodParams& params) {
           gdImage& image=GET_SELF(r, VImage).image();
   
           image.Sector(
                   params.as_int(0, "center_x must be int", r), 
                   params.as_int(1, "center_y must be int", r), 
                   params.as_int(2, "width must be int", r), 
                   params.as_int(3, "height must be int", r), 
                   params.as_int(4, "start degrees must be int", r), 
                   params.as_int(5, "end degrees must be int", r), 
                   image.Color(params.as_int(6, "color must be int", r)));
   }
   
   static void _circle(Request& r, MethodParams& params) {
           gdImage& image=GET_SELF(r, VImage).image();
   
           int size=params.as_int(2, "radius must be int", r)*2;
           image.Arc(
                   params.as_int(0, "center_x must be int", r), 
                   params.as_int(1, "center_y must be int", r), 
                   size, //w
                   size, //h
                   0, //s
                   360, //e
                   image.Color(params.as_int(3, "color must be int", r)));
   }
   
   gdImage& as_image(MethodParams& params, int index, const char* msg) {
           Value& value=params.as_no_junction(index, msg);
   
           if(Value* vimage=value.as(VIMAGE_TYPE)) {
                   return static_cast<VImage *>(vimage)->image();
           } else
                   throw Exception(PARSER_RUNTIME, 0, msg);
   }
   
   static void _copy(Request& r, MethodParams& params) {
           gdImage& dest=GET_SELF(r, VImage).image();
   
           gdImage& src=as_image(params, 0, "src must be image");
   
           int sx=params.as_int(1, "src_x must be int", r);
           int sy=params.as_int(2, "src_y must be int", r);
           int sw=params.as_int(3, "src_w must be int", r);
           int sh=params.as_int(4, "src_h must be int", r);
           int dx=params.as_int(5, "dest_x must be int", r);
           int dy=params.as_int(6, "dest_y must be int", r);
           if(params.count()>1+2+2+2) {
                   int dw=params.as_int(1+2+2+2, "dest_w must be int", r);
                   int dh=(int)(params.count()>1+2+2+2+1?
                           params.as_int(1+2+2+2+1, "dest_h must be int", r):sh*(((double)dw)/((double)sw)));
                   int tolerance=params.count()>1+2+2+2+2?
                           params.as_int(1+2+2+2+2, "tolerance must be int", r):150;
   
                   src.CopyResampled(dest, dx, dy, sx, sy, dw, dh, sw, sh, tolerance);
           } else
                   src.Copy(dest, dx, dy, sx, sy, sw, sh);
   }
   
         if(params->size()) {  static void _pixel(Request& r, MethodParams& params) {
                 if(temporary=static_cast<Value *>(params->get(0))->get_hash()) {          gdImage& image=GET_SELF(r, VImage).image();
                         Attrib_info attrib_info={&tag, 0};  
                         temporary->for_each(append_attrib_pair, &attrib_info);          int x=params.as_int(0, "x must be int", r); 
                 } else          int y=params.as_int(1, "y must be int", r);
                         PTHROW(0, 0,  
                                 &method_name,          if(params.count()>2) {
                                 "parameter must be hash");                  image.SetPixel(x, y, 
         }                          image.Color(params.as_int(2, "color must be int", r)));
           } else 
         Attrib_info attrib_info={&tag, temporary};                  r.write(*new VInt(image.DecodeColor(image.GetPixel(x, y))));
         fields.for_each(append_attrib_pair, &attrib_info);  
         tag << ">";  
         r.write_pass_lang(tag);  
 }  }
   
 // initialize  
 void initialize_image_class(Pool& pool, VStateless_class& vclass) {  // constructor
   
   MImage::MImage(): Methoded("image") {
         // ^image:measure[DATA]          // ^image:measure[DATA]
         vclass.add_native_method("measure", Method::CT_DYNAMIC, _measure, 1, 1);          // ^image:measure[DATA; $.exif(false) $.xmp(false) $.xmp-charset[UTF-8] ]
           add_native_method("measure", Method::CT_DYNAMIC, _measure, 1, 2);
   
           // ^image.html[]
           // ^image.html[hash]
           add_native_method("html", Method::CT_DYNAMIC, _html, 0, 1);
   
           // ^image.load[background.gif]
           add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
   
           // ^image.create[width;height] bgcolor=white
           // ^image.create[width;height;bgcolor]
           add_native_method("create", Method::CT_DYNAMIC, _create, 2, 3);
   
           // ^image.gif[]
           add_native_method("gif", Method::CT_DYNAMIC, _gif, 0, 1);
   
           // ^image.line(x0;y0;x1;y1;color)
           add_native_method("line", Method::CT_DYNAMIC, _line, 5, 5);
   
           // ^image.fill(x;y;color)
           add_native_method("fill", Method::CT_DYNAMIC, _fill, 3, 3);
   
           // ^image.rectangle(x0;y0;x1;y1;color)
           add_native_method("rectangle", Method::CT_DYNAMIC, _rectangle, 5, 5);
   
           // ^image.bar(x0;y0;x1;y1;color)
           add_native_method("bar", Method::CT_DYNAMIC, _bar, 5, 5);
   
           // ^image.replace(color-source;color-dest)[table x:y]
           // ^image.replace(color-source;color-dest)
           add_native_method("replace", Method::CT_DYNAMIC, _replace, 2, 3);
   
           // ^image.polyline(color)[table x:y]
           add_native_method("polyline", Method::CT_DYNAMIC, _polyline, 2, 2);
   
           // ^image.polygon(color)[table x:y]
           add_native_method("polygon", Method::CT_DYNAMIC, _polygon, 2, 2);
   
           // ^image.polybar(color)[table x:y]
           add_native_method("polybar", Method::CT_DYNAMIC, _polybar, 2, 2);
   
           // ^image.font[alPHAbet;font-file-name.gif]
           // ^image.font[alPHAbet;font-file-name.gif](spacebar_width)
           // ^image.font[alPHAbet;font-file-name.gif](spacebar_width;letter_width)
           // ^image.font[alPHAbet;font-file-name.gif][$.space-width(.) $.letter-width(.) $.letter-space(.)]
           add_native_method("font", Method::CT_DYNAMIC, _font, 2, 4);
   
           // ^image.text(x;y)[text]
           add_native_method("text", Method::CT_DYNAMIC, _text, 3, 3);
           
           // ^image.length[text]
           add_native_method("length", Method::CT_DYNAMIC, _length, 1, 1);
           
           // ^image.arc(center x;center y;width;height;start in degrees;end in degrees;color)
           add_native_method("arc", Method::CT_DYNAMIC, _arc, 7, 7);
   
           // ^image.sector(center x;center y;width;height;start in degrees;end in degrees;color)
           add_native_method("sector", Method::CT_DYNAMIC, _sector, 7, 7);
   
           // ^image.circle(center x;center y;r;color)
           add_native_method("circle", Method::CT_DYNAMIC, _circle, 4, 4);
   
           // ^image.copy[source](src x;src y;src w;src h;dst x;dst y[;dest w[;dest h[;tolerance]]])
           add_native_method("copy", Method::CT_DYNAMIC, _copy, 1+2+2+2, (1+2+2+2)+2+1);
   
         /// ^image.html[]          // ^image.pixel(x;y)[(color)]
         /// ^image.html[hash]          add_native_method("pixel", Method::CT_DYNAMIC, _pixel, 2, 3);
         vclass.add_native_method("html", Method::CT_DYNAMIC, _html, 0, 1);  
 }  }
Removed from v.1.4  
changed lines
  Added in v.1.174

E-mail: