[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.71 and 1.90.2.5

version 1.71, 2002/04/18 10:50:59 version 1.90.2.5, 2003/02/04 14:12:41
Line 1 Line 1
 /** @file  /** @file
         Parser: @b image parser class.          Parser: @b image parser class.
   
         Copyright(c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)          Copyright(c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
   
         $Id$  
 */  */
   
   static const char* IDENT_IMAGE_C="$Date$";
   
 /*  /*
         jpegsize: gets the width and height (in pixels) of a jpeg file          jpegsize: gets the width and height (in pixels) of a jpeg file
         Andrew Tong, werdna@ugcs.caltech.edu           February 14, 1995          Andrew Tong, werdna@ugcs.caltech.edu           February 14, 1995
Line 18 Line 18
   
 #include "pa_config_includes.h"  #include "pa_config_includes.h"
   
   #include "pa_vmethod_frame.h"
   
 #include "gif.h"  #include "gif.h"
   
 #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"
   
 // class  // class
   
 class MImage : public Methoded {  class MImage : public Methoded {
 public: // VStateless_class  public: // VStateless_class
         Value *create_new_value(Pool& pool) { return new(pool) VImage(pool); }          ValuePtr create_new_value() { return ValuePtr(new VImage()); }
   
 public:  public:
         MImage(Pool& pool);          MImage(Pool& pool);
Line 41  public: // Methoded Line 44  public: // Methoded
   
 // helpers  // helpers
   
   /// value of exif tag -> it's value
   Hash<int, const char* > exif_tag_value2name;
   
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 class Measure_reader {  class Measure_reader {
 public:  public:
         enum { READ_CHUNK_SIZE=0x400*20 };// 20K          virtual size_t read(const void *&buf, size_t limit)=0;
         typedef size_t(*Func)(void *& buf, size_t limit, void *info);          virtual void seek(long value, int whence)=0;
           virtual long tell()=0;
   };
   
         Measure_reader(Func afunc, void *ainfo) :   class Measure_file_reader: public Measure_reader {
                 func(afunc), info(ainfo),   public:
                 chunk(0), offset(0), size(0) {          Measure_file_reader(Pool& apool, int af, const String& afile_name, const char* afname): 
                   pool(apool), file_name(afile_name), fname(afname), f(af) {
         }          }
   
         size_t read(void *&buf, size_t limit) {          /*override*/size_t read(const void *&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                  void *lbuf=pool.malloc(limit);
                 size_t read_size=min(offset+limit, size)-offset;                  size_t read_size=(size_t)::read(f, lbuf, limit);  abuf=lbuf;
                 buf=((unsigned char *)chunk)+offset;                  if(ssize_t(read_size)<0 || read_size>limit)
                 offset+=read_size;                          throw Exception(0,
                                   &file_name, 
                                   "measure failed: actually read %lu bytes count not in [0..%lu] valid range", 
                           read_size, limit);
   
                 return read_size;                  return read_size;
         }          }
   
           /*override*/void seek(long value, int whence) {
                   if(lseek(f, value, whence)<0)
                           throw Exception("image.format",
                                   &file_name, 
                                   "seek(value=%ld, whence=%d) failed: %s (%d), actual filename '%s'", 
                                           value, whence, strerror(errno), errno, fname);
           }
   
           /*override*/long tell() { return lseek(f, 0, SEEK_CUR); }
   
   private:
           Pool& pool;
           const String& file_name; const char* fname;
           int f;
   };
   
   class Measure_buf_reader: public Measure_reader {
   public:
           Measure_buf_reader(const void *abuf, size_t asize, const String& afile_name): 
                   buf(abuf), size(asize), file_name(afile_name), offset(0) {
           }
           
           /*override*/size_t read(const void *&abuf, size_t limit) {
                   size_t to_read=min(limit, size-offset);
                   abuf=(const char*)buf+offset;
                   offset+=to_read;
                   return to_read;
           }
   
           /*override*/void seek(long value, int whence) {
                   size_t new_offset;
                   switch(whence) {
                   case SEEK_CUR: new_offset=offset+value; break;
                   case SEEK_SET: new_offset=(size_t)value; break;
                   default: throw Exception(0, 0, "whence #%d not supported", 0, whence); break; // never
                   }
                   
                   if((ssize_t)new_offset<0 || new_offset>size)
                           throw Exception("image.format",
                                   &file_name, 
                                   "seek(value=%l, whence=%d) failed: out of buffer, new_offset>size (%l>%l) or new_offset<0", 
                                           value, whence, new_offset, size);
                   offset=new_offset;
           }
   
           /*override*/long tell() { return offset; }
   
 private:  private:
         Func func;  
         void *info;  
   
         void *chunk;          const void *buf; size_t size;
           const String& file_name; 
   
         size_t offset;          size_t offset;
         size_t size;  
 };  };
   
 #endif  #endif
   
   /// PNG file header
   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
   };
   
 /// GIF file header  /// GIF file header
 struct GIF_Header {  struct GIF_Header {
         char       type[3];         // 'GIF'          char       signature[3];         // 'GIF'
         char       version[3];          char       version[3];
         unsigned char       width[2];          uchar       width[2];
         unsigned char       height[2];          uchar       height[2];
         char       dif;          char       dif;
         char       fonColor;          char       fonColor;
         char       nulls;          char       nulls;
Line 92  struct GIF_Header { Line 157  struct GIF_Header {
   
 /// JPEG record head  /// JPEG record head
 struct JPG_Segment_head {  struct JPG_Segment_head {
         unsigned char marker;          uchar marker;
         unsigned char code;          uchar code;
         unsigned char length[2];          uchar length[2];
 };  };
 /// JPEG frame header  /// JPEG frame header
 struct JPG_Size_segment_body {  struct JPG_Size_segment_body {
         char data;                    //< data precision of bits/sample          char data;                    //< data precision of bits/sample
         unsigned char height[2];               //< image height          uchar height[2];               //< image height
         unsigned char width[2];                //< image width          uchar width[2];                //< image width
         char numComponents;           //< number of color components          char numComponents;           //< number of color components
 };  };
   
   /// JPEG frame header
   struct JPG_Exif_segment_start {
           char signature[6]; // Exif\0\0
   };
   
   /// JPEG Exif TIFF Header
   struct JPG_Exif_TIFF_header {
           uchar byte_align_identifier[2];
           char dummy[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_start {
           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 JPEG_EXIF_DATE_CHARS 20
   
 //  //
   
 inline short x_endian_to_int(unsigned char L, unsigned char H) {  inline ushort x_endian_to_ushort(uchar b0, uchar b1) {
         return(short)((H<<8) + L);          return (ushort)((b1<<8) + b0);
   }
   
   inline uint x_endian_to_uint(uchar b0, uchar b1, uchar b2, uchar b3) {
           return (uint)(((((b3<<8) + b2)<<8)+b1)<<8)+b0;
 }  }
   
 inline short big_endian_to_int(unsigned char b[2]) {  inline ushort endian_to_ushort(bool is_big, const uchar *b/* [2] */) {
         return x_endian_to_int(b[1], b[0]);          return is_big?x_endian_to_ushort(b[1], b[0]):
                   x_endian_to_ushort(b[0], b[1]);
 }  }
   
 inline short little_endian_to_int(unsigned char b[2]) {  inline uint endian_to_uint(bool is_big, const uchar *b /* [4] */) {
         return x_endian_to_int(b[0], b[1]);          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_gif(Pool& pool, const String *origin_string,   static void measure_gif(Pool& pool, const String *origin_string, 
                          Measure_reader& reader, int& width, int& height) {                           Measure_reader& reader, ushort& width, ushort& height) {
   
         void *buf;          const void *buf;
         const int head_size=sizeof(GIF_Header);          const int head_size=sizeof(GIF_Header);
         if(reader.read(buf, head_size)<head_size)          if(reader.read(buf, head_size)<head_size)
                 throw Exception("image.format",                   throw Exception("image.format", 
Line 129  void measure_gif(Pool& pool, const Strin Line 229  void measure_gif(Pool& pool, const Strin
                         "not GIF file - too small");                          "not GIF file - too small");
         GIF_Header *head=(GIF_Header *)buf;          GIF_Header *head=(GIF_Header *)buf;
   
         if(strncmp(head->type, "GIF", 3)!=0)          if(strncmp(head->signature, "GIF", 3)!=0)
                 throw Exception("image.format",                   throw Exception("image.format", 
                         origin_string,                           origin_string, 
                         "not GIF file - wrong signature");                                "not GIF file - wrong signature");      
   
         width=little_endian_to_int(head->width);          width=endian_to_ushort(false, head->width);
         height=little_endian_to_int(head->height);          height=endian_to_ushort(false, head->height);
   }
   
   static Value *parse_IFD_entry_formatted_one_value(Pool& pool,
                                                                                                     bool is_big,
                                                                                                     ushort format, 
                                                                                                     size_t component_size, 
                                                                                                     const uchar *value) {
           switch(format) {
           case 1: // unsigned byte
                   return new(pool) VInt(pool, (uchar)value[0]);
           case 3: // unsigned short
                   return new(pool) VInt(pool, endian_to_ushort(is_big, value));
           case 4: // unsigned long
                    // 'double' because parser's Int is signed
                   return new(pool) VDouble(pool, 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(pool) VDouble(pool, ((double)numerator)/denominator);
                   }
           case 6: // signed byte
                   return new(pool) VInt(pool, (signed char)value[0]);
           case 8: // signed short
                   return new(pool) VInt(pool, (signed short)endian_to_ushort(is_big, value));
           case 9: // signed long
                   return new(pool) VInt(pool, (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(pool) VDouble(pool, numerator/denominator);
                   }
                   /*
           case 11: // single float
                   todo
           case 12: // double float
                   todo
                   */
           };      
           
           return 0;
   }
   
   // date.C
   time_t cstr_to_time_t(char *cstr, const String *report_error_origin);
   
   static Value *parse_IFD_entry_formatted_value(Pool& pool,
                                                                                             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 size=components_count;
                   // Data format is "YYYY:MM:DD HH:MM:SS"+0x00, total 20bytes
                   if(size==JPEG_EXIF_DATE_CHARS 
                           && isdigit(cstr[0])
                           && cstr[JPEG_EXIF_DATE_CHARS-1]==0) {
                           char cstr_writable[JPEG_EXIF_DATE_CHARS]; 
                           strcpy(cstr_writable, cstr);
   
                           time_t t=cstr_to_time_t(cstr_writable, 0/* do not throw exception, just return bad result */);
                           if(t>=0)
                                   return new(pool) VDate(pool, t);
                   }
   
                   if(const char* premature_zero_pos=(const char* )memchr(cstr, 0, size))
                           size=premature_zero_pos-cstr;
                   return new(pool) VString(*new(pool) String(pool, cstr, size, true/*tainted*/));
           }
   
           if(components_count==1)
                   return parse_IFD_entry_formatted_one_value(pool, is_big, format, component_size, value);
   
           VHash& result=*new(pool) VHash(pool);
           Hash& hash=result.hash(0);
           for(uint i=0; i<components_count; i++, value+=component_size) {
                   String& skey=*new(pool) String(pool);
                   {
                           char *buf=(char *)pool.malloc(MAX_NUMBER);
                           snprintf(buf, MAX_NUMBER, "%d", i);
                           skey << buf;
                   }
                   hash.put(skey, parse_IFD_entry_formatted_one_value(pool, is_big, format, component_size, value));
           }
   
           return &result;
 }  }
   
 /// @test remove ugly mech in reader - 20K limit  static Value *parse_IFD_entry_value(Pool& pool,
 void measure_jpeg(Pool& pool, const String *origin_string,                                                                           bool is_big, Measure_reader& reader, long tiff_base,
                          Measure_reader& reader, int& width, int& height) {                                                                          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);
           size_t 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(pool,
                           is_big, format, 
                           component_size, components_count, 
                           entry.value_or_offset_to_it);
           else {
                   long remembered=reader.tell();
                   {
                           reader.seek(tiff_base+endian_to_uint(is_big, entry.value_or_offset_to_it), SEEK_SET);
                           const void *value;
                           if(reader.read(value, value_size)<sizeof(value_size))
                                   return 0;
                           result=parse_IFD_entry_formatted_value(pool,
                                   is_big, format, 
                                   component_size, components_count, 
                                   (const uchar*)value);
                   }
                   reader.seek(remembered, SEEK_SET);
           }
   
           return result;
   }
   
   static void parse_IFD(Pool& pool,
                                             Hash& hash,
                                             bool is_big, Measure_reader& reader, long tiff_base);
   
   static void parse_IFD_entry(Pool& pool, Hash& hash,
                                                           bool is_big, Measure_reader& reader, long tiff_base,
                                                           JPG_Exif_IFD_entry& entry) {
           ushort tag=endian_to_ushort(is_big, entry.tag);
           if(tag==JPG_IFD_TAG_EXIF_OFFSET) {
                   long remembered=reader.tell();
                   {
                           reader.seek(tiff_base+endian_to_uint(is_big, entry.value_or_offset_to_it), SEEK_SET);
                           parse_IFD(pool, hash, is_big, reader, tiff_base);
                   }
                   reader.seek(remembered, SEEK_SET);
                   return;
           }
           
           if(Value *value=parse_IFD_entry_value(pool, is_big, reader, tiff_base, entry)) {
                   String& skey=*new(pool) String(pool);
                   {
                           char *buf=(char *)pool.malloc(MAX_NUMBER);
                           snprintf(buf, MAX_NUMBER, "%u", tag);
                           skey << buf;
                   }
   
                   if(const char* name=(const char* )exif_tag_value2name->get(skey))
                           hash.put(*new(pool) String(pool, name), value);
                   else
                           hash.put(skey, value);
           }
   }
   
   static void parse_IFD(Pool& pool,
                                             Hash& hash,
                                             bool is_big, Measure_reader& reader, long tiff_base) {
           const void *buf;
           if(reader.read(buf, sizeof(JPG_Exif_IFD_start))<sizeof(JPG_Exif_IFD_start))
                   return;
           JPG_Exif_IFD_start *start=(JPG_Exif_IFD_start *)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(pool, hash, is_big, reader, tiff_base, *(JPG_Exif_IFD_entry *)buf);
           }
           // then goes: LLLLLLLL Offset to next IFD [not going there]
   }
   
   static Value *parse_exif(Pool& pool,
                                              Measure_reader& reader,
                                              const String *origin_string) {
           const void *buf;
           if(reader.read(buf, sizeof(JPG_Exif_segment_start))<sizeof(JPG_Exif_segment_start))
                   throw Exception("image.format", 
                           origin_string, 
                           "not JPEG file - can not fully read Exif segment start");
   
           JPG_Exif_segment_start *start=(JPG_Exif_segment_start *)buf;
           if(memcmp(start->signature, "Exif\0\0", 4+2)!=0) //signature invalid?
                   return 0; // ignore invalid block
   
           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, SEEK_SET);
   
           VHash& vhash=*new(pool) VHash(pool);
   
           // IFD
           parse_IFD(pool, vhash.hash(0), is_big, reader, tiff_base);
   
           return &vhash;
   }
   
   static void measure_jpeg(Pool& pool, const String *origin_string, 
                            Measure_reader& reader, ushort& width, ushort& height, Value ** exif) {
         // JFIF format markers          // JFIF format markers
         const unsigned char MARKER=0xFF;          const uchar MARKER=0xFF;
         const unsigned char CODE_SIZE_FIRST=0xC0;          const uchar CODE_SIZE_A=0xC0;
         const unsigned char CODE_SIZE_LAST=0xC3;          const uchar CODE_SIZE_B=0xC1;
           const uchar CODE_SIZE_C=0xC2;
           const uchar CODE_SIZE_D=0xC3;
           const uchar CODE_EXIF=0xE1;
   
         void *buf;          const void *buf;
         const size_t prefix_size=2;          const size_t prefix_size=2;
         if(reader.read(buf, prefix_size)<prefix_size)          if(reader.read(buf, prefix_size)<prefix_size)
                 throw Exception("image.format",                   throw Exception("image.format", 
                         origin_string,                           origin_string, 
                         "not JPEG file - too small");                          "not JPEG file - too small");
         unsigned char *signature=(unsigned char *)buf;          uchar *signature=(uchar *)buf;
                   
         if(!(signature[0]==0xFF && signature[1]==0xD8))           if(!(signature[0]==0xFF && signature[1]==0xD8)) 
                 throw Exception("image.format",                   throw Exception("image.format", 
                         origin_string,                           origin_string, 
                         "not JPEG file - wrong signature");                          "not JPEG file - wrong signature");
   
         bool found=false;  
         while(true) {          while(true) {
                 void *buf;                  uint segment_base=reader.tell()+2/*marker,code*/;
         // Extract the segment header.  
                 if(reader.read(buf, sizeof(JPG_Segment_head))<sizeof(JPG_Segment_head))                  if(reader.read(buf, sizeof(JPG_Segment_head))<sizeof(JPG_Segment_head))
                         break;                                    break;
                 JPG_Segment_head *head=(JPG_Segment_head *)buf;                  JPG_Segment_head *head=(JPG_Segment_head *)buf;
   
         // Verify that it's a valid segment.          // Verify that it's a valid segment.
                 if(head->marker!=MARKER)                  if(head->marker!=MARKER)
                         break;                          throw Exception("image.format", 
                                   origin_string, 
                                   "not JPEG file - marker not found");
   
                 if(head->code >= CODE_SIZE_FIRST && head->code  <= CODE_SIZE_LAST) {                  switch(head->code) {
             // Segments that contain size info                  // http://www.ba.wakwak.com/~tsuruzoh/Computer/Digicams/exif-e.html
                         if(reader.read(buf, sizeof(JPG_Size_segment_body))<sizeof(JPG_Size_segment_body))                  case CODE_EXIF:
                                 break;                          if(exif && !*exif) // seen .jpg with some xml under EXIF tag, after real exif block :)
                         JPG_Size_segment_body *body=(JPG_Size_segment_body *)buf;                                  *exif=parse_exif(pool, reader, origin_string);
                           
                         width=big_endian_to_int(body->width);  
                         height=big_endian_to_int(body->height);  
                         found=true;  
                         break;                          break;
                 } else {  
             // Dummy read to skip over data                  case CODE_SIZE_A:
             size_t limit=big_endian_to_int(head->length) - 2;                  case CODE_SIZE_B:
                         if(reader.read(buf, limit)<limit)                  case CODE_SIZE_C:
                                 break;                  case CODE_SIZE_D:
         }                          {
                                   // 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;
                                   
                                   width=endian_to_ushort(true, body->width);
                                   height=endian_to_ushort(true, body->height);
                           }                       
                           return;
                   };
   
                   reader.seek(segment_base+endian_to_ushort(true, head->length), SEEK_SET);
         }          }
   
         if(!found)          throw Exception("image.format", 
                   origin_string, 
                   "broken JPEG file - size frame not found");
   }
   
   static void measure_png(Pool& pool, const String *origin_string, 
                            Measure_reader& reader, ushort& width, ushort& height) {
   
           const void *buf;
           const int 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",                   throw Exception("image.format", 
                         origin_string,                           origin_string, 
                         "broken JPEG file - size frame not found");                          "not PNG file - wrong signature");      
   
           width=endian_to_ushort(true, head->width);
           height=endian_to_ushort(true, head->height);
 }  }
   
 // measure center  // measure center
   
 void measure(Pool& pool, const String& file_name,   static void measure(Pool& pool, const String& file_name, 
                          Measure_reader& reader, int& width, int& height) {                           Measure_reader& reader, ushort& width, ushort& height, Value ** exif) {
         if(const char *cext=strrchr(file_name.cstr(String::UL_FILE_SPEC), '.')) {          if(const char* cext=strrchr(file_name.cstr(String::UL_FILE_SPEC), '.')) {
                 cext++;                  cext++;
                 if(strcasecmp(cext, "GIF")==0)                  if(strcasecmp(cext, "GIF")==0)
                         measure_gif(pool, &file_name, reader, width, height);                          measure_gif(pool, &file_name, reader, width, 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(pool, &file_name, reader, width, height, exif);
                   else if(strcasecmp(cext, "PNG")==0)
                           measure_png(pool, &file_name, reader, width, height);
                 else                  else
                         throw Exception("image.format",                           throw Exception("image.format", 
                                 &file_name,                                   &file_name, 
Line 215  void measure(Pool& pool, const String& f Line 580  void measure(Pool& pool, const String& f
                         "can not determine image type - no file name extension");                          "can not determine image type - no file name extension");
 }  }
   
 #ifndef DOXYGEN  // methods
 struct Read_mem_info {  
         unsigned char *ptr;  
         unsigned char *eof;  
 };  
 #endif  
 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;  
 }  
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct Read_disk_info {  struct File_measure_action_info {
         const String *file_spec;          ushort *width;
         size_t offset;          ushort *height;
           Value ** exif;
           const String *file_name;
 };  };
 #endif  #endif
 static size_t read_disk(void*& buf, size_t limit, void *info) {  static void file_measure_action(Pool& pool,
         Read_disk_info& rdi=*static_cast<Read_disk_info *>(info);                                                                  struct stat& finfo, int f, 
         Pool& pool=rdi.file_spec->pool();                                                                  const String& file_spec, const char* fname, bool as_text,
                                                                   void *context) {
         size_t read_size;          File_measure_action_info& info=*static_cast<File_measure_action_info *>(context);
         file_read(pool, *rdi.file_spec,   
                            buf, read_size,   
                            false/*as_text*/,   
                            true/*fail_on_read_problem*/,   
                            rdi.offset, limit);  
   
         rdi.offset+=read_size;          Measure_file_reader reader(pool, f, *info.file_name, fname);
         return read_size;          measure(pool, *info.file_name, reader, *info.width, *info.height, info.exif);
 }  }
   
 // methods  static void _measure(Request& r, StringPtr method_name, MethodParams& params) {
   
 static void _measure(Request& r, const String& method_name, MethodParams *params) {  
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         Value& data=params->as_no_junction(0, "data must not be code");          Value& data=params.as_no_junction(0, "data must not be code");
   
         void *info;Measure_reader::Func read_func;          ushort width=0;
         Read_mem_info read_mem_info;          ushort height=0;
         Read_disk_info read_disk_info;          Value *exif=0;
         const String *file_name;          const String *file_name;
         if(data.is_string()) {          if(file_name=data.get_string()) {
                 file_name=data.get_string();                  File_measure_action_info info={&width, &height, &exif, file_name};
                 read_disk_info.file_spec=&r.absolute(*file_name);                  file_read_action_under_lock(pool, r.absolute(*file_name), 
                 read_disk_info.offset=0;                          "measure", file_measure_action, &info);
                 info=&read_disk_info;read_func=read_disk;  
         } else {          } else {
                 const VFile& vfile=*data.as_vfile();                  const VFile& vfile=*data.as_vfile();
                 file_name=&static_cast<Value *>(vfile.fields().get(*name_name))->as_string();                  file_name=&static_cast<Value *>(vfile.fields().get(*name_name))->as_string();
                 read_mem_info.ptr=(unsigned char *)vfile.value_ptr();                  Measure_buf_reader reader(
                 read_mem_info.eof=read_mem_info.ptr+vfile.value_size();                          vfile.value_ptr(),
                 info=&read_mem_info;read_func=read_mem;                          vfile.value_size(),
                           *file_name
                   );
                   measure(pool, *file_name, reader, width, height, &exif);
         }          }
   
         Measure_reader reader(read_func, info);          VImage &vimage=*static_cast<VImage *>(r.get_self());
         int width, height;          vimage.set(file_name, width, height, 0, exif);
         measure(pool, *file_name, reader, width, height);  
   
         static_cast<VImage *>(r.self)->set(file_name, width, height);  
 }  }
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
Line 300  static void append_attrib_pair(const Has Line 647  static void append_attrib_pair(const Has
         if(value.is_string() || value.as_int()>=0)          if(value.is_string() || value.as_int()>=0)
                 *ai.tag << "=\"" << value.as_string() << "\"";                  *ai.tag << "=\"" << value.as_string() << "\"";
 }  }
 static void _html(Request& r, const String& method_name, MethodParams *params) {  static void _html(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         String tag(pool);          String tag(pool);
         tag << "<img";          tag << "<img";
   
         const Hash& fields=static_cast<VImage *>(r.self)->fields();          const Hash& fields=static_cast<VImage *>(r.get_self())->fields();
         Hash *attribs=0;          Hash *attribs=0;
   
         if(params->size()) {          if(params.count()) {
                 // for backward compatibility: someday was ^html{}                  // for backward compatibility: someday was ^html{}
                 Value &vattribs=r.process_to_value(params->get(0),                  Value &vattribs=r.process_to_value(params.get(0),
                         /*0/*no name* /,*/                          /*0/*no name* /,*/
                         false/*don't intercept string*/);                          false/*don't intercept string*/);
                 if(vattribs.is_defined()) // allow 'void'                  if(!vattribs.is_string()) // allow empty
                         if(attribs=vattribs.get_hash(&method_name)) {                          if(attribs=vattribs.get_hash(&method_name)) {
                                 Attrib_info attrib_info={&tag, 0};                                  Attrib_info attrib_info={&tag, 0};
                                 attribs->for_each(append_attrib_pair, &attrib_info);                                  attribs->for_each(append_attrib_pair, &attrib_info);
Line 335  static gdImage *load(Request& r, const S Line 682  static gdImage *load(Request& r, const S
                                          const String& file_name){                                           const String& file_name){
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         const char *file_name_cstr=r.absolute(file_name).cstr(String::UL_FILE_SPEC);          const char* file_name_cstr=r.absolute(file_name).cstr(String::UL_FILE_SPEC);
         if(FILE *f=fopen(file_name_cstr, "rb")) {          if(FILE *f=fopen(file_name_cstr, "rb")) {
                 gdImage& image=*new(pool) gdImage(pool);                  gdImage& image=*new(pool) gdImage(pool);
                 bool ok=image.CreateFromGif(f);                  bool ok=image.CreateFromGif(f);
Line 354  static gdImage *load(Request& r, const S Line 701  static gdImage *load(Request& r, const S
 }  }
   
   
 static void _load(Request& r, const String& method_name, MethodParams *params) {  static void _load(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         const String& file_name=params->as_string(0, "file name must not be code");          const String& file_name=params.as_string(0, "file name must not be code");
   
         gdImage& image=*load(r, method_name, file_name);          gdImage& image=*load(r, method_name, file_name);
         int width=image.SX();          int width=image.SX();
         int height=image.SY();          int height=image.SY();
         static_cast<VImage *>(r.self)->set(&file_name, width, height, &image);          static_cast<VImage *>(r.get_self())->set(&file_name, width, height, &image);
 }  }
   
 static void _create(Request& r, const String& method_name, MethodParams *params) {  static void _create(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         int width=params->as_int(0, "width must be int", r);          int width=params.as_int(0, "width must be int", r);
         int height=params->as_int(1, "height must be int", r);          int height=params.as_int(1, "height must be int", r);
         int bgcolor_value=0xffFFff;          int bgcolor_value=0xffFFff;
         if(params->size()>2)          if(params.count()>2)
                 bgcolor_value=params->as_int(2, "color must be int", r);                  bgcolor_value=params.as_int(2, "color must be int", r);
         gdImage& image=*new(pool) gdImage(pool);          gdImage& image=*new(pool) gdImage(pool);
         image.Create(width, height);          image.Create(width, height);
         image.FilledRectangle(0, 0, width-1, height-1, image.Color(bgcolor_value));          image.FilledRectangle(0, 0, width-1, height-1, image.Color(bgcolor_value));
         static_cast<VImage *>(r.self)->set(0, width, height, &image);          static_cast<VImage *>(r.get_self())->set(0, width, height, &image);
 }  }
   
 static void _gif(Request& r, const String& method_name, MethodParams *params) {  static void _gif(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 throw Exception(0,                   throw Exception(0, 
                         &method_name,                           &method_name, 
Line 400  static void _gif(Request& r, const Strin Line 747  static void _gif(Request& r, const Strin
         r.write_no_lang(vfile);          r.write_no_lang(vfile);
 }  }
   
 static void _line(Request& r, const String& method_name, MethodParams *params) {  static void _line(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 throw Exception(0,                   throw Exception(0, 
                         &method_name,                           &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         image->Line(          image->Line(
                 params->as_int(0, "x0 must be int", r),                   params.as_int(0, "x0 must be int", r), 
                 params->as_int(1, "y0 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(2, "x1 must be int", r), 
                 params->as_int(3, "y1 must be int", r),                   params.as_int(3, "y1 must be int", r), 
                 image->Color(params->as_int(4, "color must be int", r)));                  image->Color(params.as_int(4, "color must be int", r)));
 }  }
   
 static void _fill(Request& r, const String& method_name, MethodParams *params) {  static void _fill(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 throw Exception(0,                   throw Exception(0, 
                         &method_name,                           &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         image->Fill(          image->Fill(
                 params->as_int(0, "x must be int", r),                   params.as_int(0, "x must be int", r), 
                 params->as_int(1, "y must be int", r),                   params.as_int(1, "y must be int", r), 
                 image->Color(params->as_int(2, "color must be int", r)));                  image->Color(params.as_int(2, "color must be int", r)));
 }  }
   
 static void _rectangle(Request& r, const String& method_name, MethodParams *params) {  static void _rectangle(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 throw Exception(0,                   throw Exception(0, 
                         &method_name,                           &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         image->Rectangle(          image->Rectangle(
                 params->as_int(0, "x0 must be int", r),                   params.as_int(0, "x0 must be int", r), 
                 params->as_int(1, "y0 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(2, "x1 must be int", r), 
                 params->as_int(3, "y1 must be int", r),                   params.as_int(3, "y1 must be int", r), 
                 image->Color(params->as_int(4, "color must be int", r)));                  image->Color(params.as_int(4, "color must be int", r)));
 }  }
   
 static void _bar(Request& r, const String& method_name, MethodParams *params) {  static void _bar(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 throw Exception(0,                   throw Exception(0, 
                         &method_name,                           &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         image->FilledRectangle(          image->FilledRectangle(
                 params->as_int(0, "x0 must be int", r),                   params.as_int(0, "x0 must be int", r), 
                 params->as_int(1, "y0 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(2, "x1 must be int", r), 
                 params->as_int(3, "y1 must be int", r),                   params.as_int(3, "y1 must be int", r), 
                 image->Color(params->as_int(4, "color must be int", r)));                  image->Color(params.as_int(4, "color must be int", r)));
 }  }
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
Line 476  static void add_point(Array::Item *value Line 823  static void add_point(Array::Item *value
         (*p)++;          (*p)++;
 }  }
 #endif  #endif
 static void _replace(Request& r, const String& method_name, MethodParams *params) {  static void _replace(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 throw Exception(0,                   throw Exception(0, 
                         &method_name,                           &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         Table *table=params->as_no_junction(2, "coordinates must not be code").get_table();          Table *table=params.as_no_junction(2, "coordinates must not be code").get_table();
         if(!table)           if(!table) 
                 throw Exception(0,                  throw Exception(0,
                         &method_name,                          &method_name,
Line 495  static void _replace(Request& r, const S Line 842  static void _replace(Request& r, const S
         gdImage::Point *add_p=all_p;              gdImage::Point *add_p=all_p;    
         table->for_each(add_point, &add_p);          table->for_each(add_point, &add_p);
         image->FilledPolygonReplaceColor(all_p, table->size(),           image->FilledPolygonReplaceColor(all_p, table->size(), 
                 image->Color(params->as_int(0, "src color must be int", r)),                  image->Color(params.as_int(0, "src color must be int", r)),
                 image->Color(params->as_int(1, "dest color must be int", r)));                  image->Color(params.as_int(1, "dest color must be int", r)));
 }  }
   
 static void _polyline(Request& r, const String& method_name, MethodParams *params) {  static void _polyline(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 throw Exception(0,                   throw Exception(0, 
                         &method_name,                           &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         Table *table=params->as_no_junction(1, "coordinates must not be code").get_table();          Table *table=params.as_no_junction(1, "coordinates must not be code").get_table();
         if(!table)           if(!table) 
                 throw Exception(0,                  throw Exception(0,
                         &method_name,                          &method_name,
Line 518  static void _polyline(Request& r, const Line 865  static void _polyline(Request& r, const
         gdImage::Point *add_p=all_p;              gdImage::Point *add_p=all_p;    
         table->for_each(add_point, &add_p);          table->for_each(add_point, &add_p);
         image->Polygon(all_p, table->size(),           image->Polygon(all_p, table->size(), 
                 image->Color(params->as_int(0, "color must be int", r)),                  image->Color(params.as_int(0, "color must be int", r)),
                 false/*not closed*/);                  false/*not closed*/);
 }  }
   
 static void _polygon(Request& r, const String& method_name, MethodParams *params) {  static void _polygon(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 throw Exception(0,                   throw Exception(0, 
                         &method_name,                           &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         Table *table=params->as_no_junction(1, "coordinates must not be code").get_table();          Table *table=params.as_no_junction(1, "coordinates must not be code").get_table();
         if(!table)           if(!table) 
                 throw Exception(0,                  throw Exception(0,
                         &method_name,                          &method_name,
Line 541  static void _polygon(Request& r, const S Line 888  static void _polygon(Request& r, const S
         gdImage::Point *add_p=all_p;              gdImage::Point *add_p=all_p;    
         table->for_each(add_point, &add_p);          table->for_each(add_point, &add_p);
         image->Polygon(all_p, table->size(),           image->Polygon(all_p, table->size(), 
                 image->Color(params->as_int(0, "color must be int", r)));                  image->Color(params.as_int(0, "color must be int", r)));
 }  }
   
 static void _polybar(Request& r, const String& method_name, MethodParams *params) {  static void _polybar(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 throw Exception(0,                   throw Exception(0, 
                         &method_name,                           &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         Table *table=params->as_no_junction(1, "coordinates must not be code").get_table();          Table *table=params.as_no_junction(1, "coordinates must not be code").get_table();
         if(!table)           if(!table) 
                 throw Exception("parser.runtime",                  throw Exception("parser.runtime",
                         &method_name,                          &method_name,
Line 563  static void _polybar(Request& r, const S Line 910  static void _polybar(Request& r, const S
         gdImage::Point *add_p=all_p;              gdImage::Point *add_p=all_p;    
         table->for_each(add_point, &add_p);          table->for_each(add_point, &add_p);
         image->FilledPolygon(all_p, table->size(),           image->FilledPolygon(all_p, table->size(), 
                 image->Color(params->as_int(0, "color must be int", r)));                  image->Color(params.as_int(0, "color must be int", r)));
 }  }
   
 // font  // font
   
 #define Y(y)(y+index*height+1)  #define Y(y)(y+index*height)
   
 /// simple gdImage-based font storage & text output   /// simple gdImage-based font storage & text output 
 class Font : public Pooled {  class Font: public Pooled {
 public:  public:
                   
         const static int letter_spacing;          const static int letter_spacing;
Line 583  public: Line 930  public:
                   
         Font(Pool& pool,           Font(Pool& pool, 
                 const String& aalphabet,                   const String& aalphabet, 
                 gdImage& aifont, int aheight, int amonospace, int aspacebarspace) : Pooled(pool),                   gdImage& aifont, int aheight, int amonospace, int aspacebarspace): Pooled(pool), 
                 alphabet(aalphabet),                   alphabet(aalphabet), 
                 height(aheight), monospace(amonospace),  spacebarspace(aspacebarspace),                  height(aheight), monospace(amonospace),  spacebarspace(aspacebarspace),
                 ifont(aifont) {                  ifont(aifont) {
Line 601  public: Line 948  public:
                         return spacebarspace;                          return spacebarspace;
                 int tr=ifont.GetTransparent();                  int tr=ifont.GetTransparent();
                 for(int x=ifont.SX()-1; x>=0; x--) {                  for(int x=ifont.SX()-1; x>=0; x--) {
                         for(int y=0; y<height-1; y++)                          for(int y=0; y<height; y++)
                                 if(ifont.GetPixel(x, Y(y))!=tr)                                   if(ifont.GetPixel(x, Y(y))!=tr) 
                                         return x+1;                                          return x+1;
                 }                  }
Line 610  public: Line 957  public:
                   
         void index_display(gdImage& image, int x, int y, int index){          void index_display(gdImage& image, int x, int y, int index){
                 if(index>=0)                   if(index>=0) 
                         ifont.Copy(image, x, y, 0, Y(0), index_width(index), height-1);                          ifont.Copy(image, x, y, 0, Y(0), index_width(index), height);
         }          }
                   
         /* ******************************** string ********************************** */          /* ******************************** string ********************************** */
                   
           int step_width(int index) {
                   return letter_spacing + (monospace ? monospace : index_width(index));
           }
   
           // counts trailing letter_spacing, consider this OK. useful for contiuations
         int string_width(const String& s){          int string_width(const String& s){
                 const char *cstr=s.cstr();                  const char* cstr=s.cstr();
                 int result=0;                  int result=0;
                 for(; *cstr; cstr++)                  for(; *cstr; cstr++)
                         result+=index_width(index_of(*cstr));                          result+=step_width(index_of(*cstr));
                 return result;                  return result;
         }          }
                   
         void string_display(gdImage& image, int x, int y, const String& s){          void string_display(gdImage& image, int x, int y, const String& s){
                 const char *cstr=s.cstr();                  const char* cstr=s.cstr();
                 if(cstr) for(; *cstr; cstr++) {                  if(cstr) for(; *cstr; cstr++) {
                         int index=index_of(*cstr);                          int index=index_of(*cstr);
                         index_display(image, x, y, index);                          index_display(image, x, y, index);
                         x+=letter_spacing + (monospace ? monospace : index_width(index));                          x+=step_width(index);
                 }                  }
         }          }
                   
 };  };
 const int Font::letter_spacing=1;  const int Font::letter_spacing=1;
   
 static void _font(Request& r, const String& method_name, MethodParams *params) {  static void _font(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         const String& alphabet=params->as_string(0, "alphabet must not be code");          const String& alphabet=params.as_string(0, "alphabet must not be code");
         gdImage& image=*load(r, method_name, params->as_string(1, "file_name must not be code"));          gdImage& image=*load(r, method_name, params.as_string(1, "file_name must not be code"));
         int spacebar_width=params->as_int(2, "spacebar_width must be int", r);          int spacebar_width=params.as_int(2, "spacebar_width must be int", r);
         int monospace_width;          int monospace_width;
         if(params->size()>3) {          if(params.count()>3) {
                 monospace_width=params->as_int(3, "monospace_width must be int", r);                  monospace_width=params.as_int(3, "monospace_width must be int", r);
                 if(!monospace_width)                  if(!monospace_width)
                         monospace_width=image.SX();                          monospace_width=image.SX();
         } else          } else
Line 653  static void _font(Request& r, const Stri Line 1005  static void _font(Request& r, const Stri
                 throw Exception("parser.runtime",                  throw Exception("parser.runtime",
                         &method_name,                          &method_name,
                         "alphabet must not be empty");                          "alphabet must not be empty");
   
           if(int remainder=image.SY() % alphabet.size())
                   throw Exception("parser.runtime",
                           &method_name,
                           "font-file height(%d) not divisable by alphabet size(%d), remainder=%d",
                                   image.SY(), alphabet.size(), remainder);
                   
         static_cast<VImage *>(r.self)->font=new(pool) Font(pool,           static_cast<VImage *>(r.get_self())->font=new(pool) Font(pool, 
                 alphabet,                   alphabet, 
                 image,                   image, 
                 image.SY() / alphabet.size(), monospace_width, spacebar_width);                  image.SY() / alphabet.size(), monospace_width, spacebar_width);
 }  }
   
 static void _text(Request& r, const String& method_name, MethodParams *params) {  static void _text(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         int x=params->as_int(0, "x must be int", r);          int x=params.as_int(0, "x must be int", r);
         int y=params->as_int(1, "y 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");          const String& s=params.as_string(2, "text must not be code");
   
         VImage& vimage=*static_cast<VImage *>(r.self);          VImage& vimage=*static_cast<VImage *>(r.get_self());
         if(vimage.image)          if(vimage.image)
                 if(vimage.font)                  if(vimage.font)
                         vimage.font->string_display(*vimage.image, x, y, s);                          vimage.font->string_display(*vimage.image, x, y, s);
Line 681  static void _text(Request& r, const Stri Line 1039  static void _text(Request& r, const Stri
                         "does not contain an image");                          "does not contain an image");
 }  }
   
 static void _length(Request& r, const String& method_name, MethodParams *params) {  static void _length(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         const String& s=params->as_string(0, "text must not be code");          const String& s=params.as_string(0, "text must not be code");
   
         VImage& vimage=*static_cast<VImage *>(r.self);          VImage& vimage=*static_cast<VImage *>(r.get_self());
         if(vimage.image)          if(vimage.image)
                 if(vimage.font) {                  if(vimage.font) {
                         r.write_no_lang(*new(pool) VInt(pool, vimage.font->string_width(s)));                          r.write_no_lang(*new(pool) VInt(pool, vimage.font->string_width(s)));
Line 700  static void _length(Request& r, const St Line 1058  static void _length(Request& r, const St
                         "does not contain an image");                          "does not contain an image");
 }  }
   
 static void _arc(Request& r, const String& method_name, MethodParams *params) {  static void _arc(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 throw Exception(0,                   throw Exception(0, 
                         &method_name,                           &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         image->Arc(          image->Arc(
                 params->as_int(0, "center_x must be int", r),                   params.as_int(0, "center_x must be int", r), 
                 params->as_int(1, "center_y 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(2, "width must be int", r), 
                 params->as_int(3, "height 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(4, "start degrees must be int", r), 
                 params->as_int(5, "end 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)));                  image->Color(params.as_int(6, "cx must be int", r)));
 }  }
   
 static void _sector(Request& r, const String& method_name, MethodParams *params) {  static void _sector(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 throw Exception(0,                   throw Exception(0, 
                         &method_name,                           &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         image->Sector(          image->Sector(
                 params->as_int(0, "center_x must be int", r),                   params.as_int(0, "center_x must be int", r), 
                 params->as_int(1, "center_y 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(2, "width must be int", r), 
                 params->as_int(3, "height 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(4, "start degrees must be int", r), 
                 params->as_int(5, "end 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)));                  image->Color(params.as_int(6, "color must be int", r)));
 }  }
   
 static void _circle(Request& r, const String& method_name, MethodParams *params) {  static void _circle(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *image=static_cast<VImage *>(r.self)->image;          gdImage *image=static_cast<VImage *>(r.get_self())->image;
         if(!image)          if(!image)
                 throw Exception(0,                   throw Exception(0, 
                         &method_name,                           &method_name, 
                         "does not contain an image");                          "does not contain an image");
   
         int size=params->as_int(2, "radius must be int", r)*2;          int size=params.as_int(2, "radius must be int", r)*2;
         image->Arc(          image->Arc(
                 params->as_int(0, "center_x must be int", r),                   params.as_int(0, "center_x must be int", r), 
                 params->as_int(1, "center_y must be int", r),                   params.as_int(1, "center_y must be int", r), 
                 size, //w                  size, //w
                 size, //h                  size, //h
                 0, //s                  0, //s
                 360, //e                  360, //e
                 image->Color(params->as_int(3, "color must be int", r)));                  image->Color(params.as_int(3, "color must be int", r)));
 }  }
   
 gdImage& as_image(Pool& pool, const String& method_name, MethodParams *params,   gdImage& as_image(Pool& pool, StringPtr method_name, MethodParams& params, 
                                                 int index, const char *msg) {                                                  int index, const char* msg) {
         Value& value=params->as_no_junction(index, msg);          gdImage *src=0;
   
         if(strcmp(value.type(), VIMAGE_TYPE)!=0)          Value& value=params.as_no_junction(index, msg);
                 throw Exception("parser.runtime",   
                         &method_name,   
                         msg);  
   
         gdImage *src=static_cast<VImage *>(&value)->image;          if(Value *vimage=value.as(VIMAGE_TYPE, false)) {
         if(!src)                  src=static_cast<VImage *>(vimage)->image;
                   if(!src)
                           throw Exception("parser.runtime", 
                                   &method_name, 
                                   msg);
           } else
                 throw Exception("parser.runtime",                   throw Exception("parser.runtime", 
                         &method_name,                           &method_name, 
                         msg);                          msg);
Line 776  gdImage& as_image(Pool& pool, const Stri Line 1136  gdImage& as_image(Pool& pool, const Stri
         return *src;          return *src;
 }  }
   
 static void _copy(Request& r, const String& method_name, MethodParams *params) {  static void _copy(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         gdImage *dest=static_cast<VImage *>(r.self)->image;          gdImage *dest=static_cast<VImage *>(r.get_self())->image;
         if(!dest)          if(!dest)
                 throw Exception(0,                   throw Exception(0, 
                         &method_name,                           &method_name, 
Line 787  static void _copy(Request& r, const Stri Line 1147  static void _copy(Request& r, const Stri
   
         gdImage& src=as_image(pool, method_name, params, 0, "src must be image");          gdImage& src=as_image(pool, method_name, params, 0, "src must be image");
   
         int sx=params->as_int(1, "src_x must be int", r);          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 sy=params.as_int(2, "src_y must be int", r);
         int sw=params->as_int(3, "src_w 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 sh=params.as_int(4, "src_h must be int", r);
         int dx=params->as_int(5, "dest_x 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);          int dy=params.as_int(6, "dest_y must be int", r);
         if(params->size()>1+2+2+2) {          if(params.count()>1+2+2+2) {
                 int dw=params->as_int(1+2+2+2, "dest_w must be int", r);                  int dw=params.as_int(1+2+2+2, "dest_w must be int", r);
                 int dh=(int)(params->size()>1+2+2+2+1?                  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)));                          params.as_int(1+2+2+2+1, "dest_h must be int", r):sh*(((double)dw)/((double)sw)));
                 int tolerance=params->size()>1+2+2+2+2?                  int tolerance=params.count()>1+2+2+2+2?
                         params->as_int(1+2+2+2+2, "tolerance must be int", r):150;                          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);                  src.CopyResampled(*dest, dx, dy, sx, sy, dw, dh, sw, sh, tolerance);
         } else          } else
Line 880  Methoded *image_class; Line 1240  Methoded *image_class;
 // creator  // creator
   
 Methoded *MImage_create(Pool& pool) {  Methoded *MImage_create(Pool& pool) {
           // image JPEG Exif
           #define EXIF_TAG(tag, name) \
                   exif_tag_value2name.put(tag, #name);
           // 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);
           #undef EXIF_TAG
   
         return image_class=new(pool) MImage(pool);          return image_class=new(pool) MImage(pool);
 }  }
Removed from v.1.71  
changed lines
  Added in v.1.90.2.5

E-mail: