Annotation of parser3/src/classes/image.C, revision 1.90.2.15.2.15
1.1 paf 1: /** @file
2: Parser: @b image parser class.
3:
1.90.2.3 paf 4: Copyright(c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)
1.66 paf 5: Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
1.73 paf 6: */
1.1 paf 7:
1.90.2.15.2.1 (paf 8:): static const char* IDENT_IMAGE_C="$Date: 2003/03/24 14:53:55 $";
1.31 parser 9:
10: /*
11: jpegsize: gets the width and height (in pixels) of a jpeg file
12: Andrew Tong, werdna@ugcs.caltech.edu February 14, 1995
13: modified slightly by alex@ed.ac.uk
14: and further still by rjray@uswest.com
15: optimization and general re-write from tmetro@vl.com
16: from perl by paf@design.ru
1.1 paf 17: */
18:
19: #include "pa_config_includes.h"
1.90.2.5 paf 20:
21: #include "pa_vmethod_frame.h"
1.1 paf 22:
1.8 paf 23: #include "gif.h"
1.6 paf 24:
1.1 paf 25: #include "pa_common.h"
26: #include "pa_request.h"
27: #include "pa_vfile.h"
28: #include "pa_vimage.h"
1.89 paf 29: #include "pa_vdate.h"
1.90.2.7 paf 30: #include "pa_table.h"
1.1 paf 31:
1.22 paf 32: // class
33:
1.90.2.9 paf 34: class MImage: public Methoded {
1.22 paf 35: public: // VStateless_class
1.90.2.15.2.1 (paf 36:): Value* create_new_value() { return new VImage(); }
1.22 paf 37:
38: public:
1.90.2.7 paf 39: MImage();
1.24 paf 40:
41: public: // Methoded
1.22 paf 42: bool used_directly() { return true; }
43:
44: };
1.1 paf 45:
1.90.2.7 paf 46: // globals
47:
1.90.2.12 paf 48: DECLARE_CLASS_VAR(image, new MImage, 0);
1.90.2.7 paf 49:
1.1 paf 50: // helpers
51:
1.90.2.1 paf 52: /// value of exif tag -> it's value
1.90.2.15.2.8 (paf 53:: class EXIF_tag_value2name: public Hash<int, const char*> {
1.90.2.7 paf 54: public:
55: EXIF_tag_value2name() {
56: // image JPEG Exif
57: #define EXIF_TAG(tag, name) \
1.90.2.15 paf 58: put(tag, #name);
1.90.2.7 paf 59: // Tags used by IFD0 (main image)
60: EXIF_TAG(0x010e, ImageDescription);
61: EXIF_TAG(0x010f, Make);
62: EXIF_TAG(0x0110, Model);
63: EXIF_TAG(0x0112, Orientation);
64: EXIF_TAG(0x011a, XResolution);
65: EXIF_TAG(0x011b, YResolution);
66: EXIF_TAG(0x0128, ResolutionUnit);
67: EXIF_TAG(0x0131, Software);
68: EXIF_TAG(0x0132, DateTime);
69: EXIF_TAG(0x013e, WhitePoint);
70: EXIF_TAG(0x013f, PrimaryChromaticities);
71: EXIF_TAG(0x0211, YCbCrCoefficients);
72: EXIF_TAG(0x0213, YCbCrPositioning);
73: EXIF_TAG(0x0214, ReferenceBlackWhite);
74: EXIF_TAG(0x8298, Copyright);
75: EXIF_TAG(0x8769, ExifOffset);
76: // Tags used by Exif SubIFD
77: EXIF_TAG(0x829a, ExposureTime);
78: EXIF_TAG(0x829d, FNumber);
79: EXIF_TAG(0x8822, ExposureProgram);
80: EXIF_TAG(0x8827, ISOSpeedRatings);
81: EXIF_TAG(0x9000, ExifVersion);
82: EXIF_TAG(0x9003, DateTimeOriginal);
83: EXIF_TAG(0x9004, DateTimeDigitized);
84: EXIF_TAG(0x9101, ComponentsConfiguration);
85: EXIF_TAG(0x9102, CompressedBitsPerPixel);
86: EXIF_TAG(0x9201, ShutterSpeedValue);
87: EXIF_TAG(0x9202, ApertureValue);
88: EXIF_TAG(0x9203, BrightnessValue);
89: EXIF_TAG(0x9204, ExposureBiasValue);
90: EXIF_TAG(0x9205, MaxApertureValue);
91: EXIF_TAG(0x9206, SubjectDistance);
92: EXIF_TAG(0x9207, MeteringMode);
93: EXIF_TAG(0x9208, LightSource);
94: EXIF_TAG(0x9209, Flash);
95: EXIF_TAG(0x920a, FocalLength);
96: EXIF_TAG(0x927c, MakerNote);
97: EXIF_TAG(0x9286, UserComment);
98: EXIF_TAG(0x9290, SubsecTime);
99: EXIF_TAG(0x9291, SubsecTimeOriginal);
100: EXIF_TAG(0x9292, SubsecTimeDigitized);
101: EXIF_TAG(0xa000, FlashPixVersion);
102: EXIF_TAG(0xa001, ColorSpace);
103: EXIF_TAG(0xa002, ExifImageWidth);
104: EXIF_TAG(0xa003, ExifImageHeight);
105: EXIF_TAG(0xa004, RelatedSoundFile);
106: EXIF_TAG(0xa005, ExifInteroperabilityOffset);
107: EXIF_TAG(0xa20e, FocalPlaneXResolution);
108: EXIF_TAG(0xa20f, FocalPlaneYResolution);
109: EXIF_TAG(0xa210, FocalPlaneResolutionUnit);
110: EXIF_TAG(0xa215, ExposureIndex);
111: EXIF_TAG(0xa217, SensingMethod);
112: EXIF_TAG(0xa300, FileSource);
113: EXIF_TAG(0xa301, SceneType);
114: EXIF_TAG(0xa302, CFAPattern);
115: // Misc Tags
116: EXIF_TAG(0x00fe, NewSubfileType);
117: EXIF_TAG(0x00ff, SubfileType);
118: EXIF_TAG(0x012d, TransferFunction);
119: EXIF_TAG(0x013b, Artist);
120: EXIF_TAG(0x013d, Predictor);
121: EXIF_TAG(0x0142, TileWidth);
122: EXIF_TAG(0x0143, TileLength);
123: EXIF_TAG(0x0144, TileOffsets);
124: EXIF_TAG(0x0145, TileByteCounts);
125: EXIF_TAG(0x014a, SubIFDs);
126: EXIF_TAG(0x015b, JPEGTables);
127: EXIF_TAG(0x828d, CFARepeatPatternDim);
128: EXIF_TAG(0x828e, CFAPattern);
129: EXIF_TAG(0x828f, BatteryLevel);
130: EXIF_TAG(0x83bb, IPTC/NAA);
131: EXIF_TAG(0x8773, InterColorProfile);
132: EXIF_TAG(0x8824, SpectralSensitivity);
133: EXIF_TAG(0x8825, GPSInfo);
134: EXIF_TAG(0x8828, OECF);
135: EXIF_TAG(0x8829, Interlace);
136: EXIF_TAG(0x882a, TimeZoneOffset);
137: EXIF_TAG(0x882b, SelfTimerMode);
138: EXIF_TAG(0x920b, FlashEnergy);
139: EXIF_TAG(0x920c, SpatialFrequencyResponse);
140: EXIF_TAG(0x920d, Noise);
141: EXIF_TAG(0x9211, ImageNumber);
142: EXIF_TAG(0x9212, SecurityClassification);
143: EXIF_TAG(0x9213, ImageHistory);
144: EXIF_TAG(0x9214, SubjectLocation);
145: EXIF_TAG(0x9215, ExposureIndex);
146: EXIF_TAG(0x9216, TIFF/EPStandardID);
147: EXIF_TAG(0xa20b, FlashEnergy);
148: EXIF_TAG(0xa20c, SpatialFrequencyResponse);
149: EXIF_TAG(0xa214, SubjectLocation);
150: #undef EXIF_TAG
151: }
152: } exif_tag_value2name;
1.90.2.1 paf 153:
154:
1.43 parser 155: #ifndef DOXYGEN
1.1 paf 156: class Measure_reader {
157: public:
1.90.2.15.2.5 (paf 158:: virtual size_t read(const char* &buf, size_t limit)=0;
1.79 paf 159: virtual void seek(long value, int whence)=0;
160: virtual long tell()=0;
1.77 paf 161: };
1.1 paf 162:
1.77 paf 163: class Measure_file_reader: public Measure_reader {
1.90.2.7 paf 164:
1.90.2.15.2.1 (paf 165:: ;
166:: const String& file_name; const char* fname;
1.90.2.7 paf 167: int f;
168:
1.77 paf 169: public:
1.90.2.15.2.1 (paf 170:: Measure_file_reader(int af, const String& afile_name, const char* afname):
1.90.2.15.2.8 (paf 171:: file_name(afile_name), fname(afname), f(af) {
1.1 paf 172: }
173:
1.90.2.15.2.5 (paf 174:: override size_t read(const char* &abuf, size_t limit) {
1.77 paf 175: if(limit==0)
1.1 paf 176: return 0;
1.77 paf 177:
1.90.2.15.2.1 (paf 178:): char* lbuf=new(PointerFreeGC) char[limit];
1.77 paf 179: size_t read_size=(size_t)::read(f, lbuf, limit); abuf=lbuf;
180: if(ssize_t(read_size)<0 || read_size>limit)
181: throw Exception(0,
1.90.2.15.2.1 (paf 182:): &file_name,
1.77 paf 183: "measure failed: actually read %lu bytes count not in [0..%lu] valid range",
184: read_size, limit);
185:
1.1 paf 186: return read_size;
187: }
188:
1.90.2.7 paf 189: override void seek(long value, int whence) {
1.79 paf 190: if(lseek(f, value, whence)<0)
1.88 paf 191: throw Exception("image.format",
1.90.2.15.2.1 (paf 192:): &file_name,
1.79 paf 193: "seek(value=%ld, whence=%d) failed: %s (%d), actual filename '%s'",
194: value, whence, strerror(errno), errno, fname);
1.77 paf 195: }
196:
1.90.2.7 paf 197: override long tell() { return lseek(f, 0, SEEK_CUR); }
1.79 paf 198:
1.77 paf 199: };
200:
201: class Measure_buf_reader: public Measure_reader {
1.90.2.7 paf 202:
203: const char* buf; size_t size;
1.90.2.15.2.1 (paf 204:: const String& file_name;
1.90.2.7 paf 205:
206: size_t offset;
207:
1.77 paf 208: public:
1.90.2.15.2.1 (paf 209:: Measure_buf_reader(const char* abuf, size_t asize, const String& afile_name):
1.77 paf 210: buf(abuf), size(asize), file_name(afile_name), offset(0) {
211: }
212:
1.90.2.15.2.5 (paf 213:: override size_t read(const char* &abuf, size_t limit) {
1.77 paf 214: size_t to_read=min(limit, size-offset);
1.90.2.7 paf 215: abuf=buf+offset;
1.77 paf 216: offset+=to_read;
217: return to_read;
218: }
219:
1.90.2.7 paf 220: override void seek(long value, int whence) {
1.79 paf 221: size_t new_offset;
222: switch(whence) {
223: case SEEK_CUR: new_offset=offset+value; break;
224: case SEEK_SET: new_offset=(size_t)value; break;
1.90.2.7 paf 225: default:
1.90.2.15.2.3 (paf 226:: throw Exception(0,
227:: 0,
1.90.2.7 paf 228: "whence #%d not supported", 0, whence);
229: break; // never
1.79 paf 230: }
231:
1.77 paf 232: if((ssize_t)new_offset<0 || new_offset>size)
1.88 paf 233: throw Exception("image.format",
1.90.2.15.2.1 (paf 234:): &file_name,
1.79 paf 235: "seek(value=%l, whence=%d) failed: out of buffer, new_offset>size (%l>%l) or new_offset<0",
236: value, whence, new_offset, size);
1.77 paf 237: offset=new_offset;
238: }
239:
1.90.2.7 paf 240: override long tell() { return offset; }
1.79 paf 241:
1.1 paf 242: };
1.77 paf 243:
1.43 parser 244: #endif
1.1 paf 245:
1.72 paf 246: /// PNG file header
247: struct PNG_Header {
248: char dummy[12];
249: char signature[4]; //< must be "IHDR"
1.80 paf 250: uchar high_width[2]; //< image width high bytes [we ignore for now]
251: uchar width[2]; //< image width low bytes
252: uchar high_height[2]; //< image height high bytes [we ignore for now]
253: uchar height[4]; //< image height
1.72 paf 254: };
255:
1.21 paf 256: /// GIF file header
1.1 paf 257: struct GIF_Header {
1.72 paf 258: char signature[3]; // 'GIF'
1.1 paf 259: char version[3];
1.80 paf 260: uchar width[2];
261: uchar height[2];
1.1 paf 262: char dif;
263: char fonColor;
264: char nulls;
265: };
266:
1.31 parser 267: /// JPEG record head
268: struct JPG_Segment_head {
1.80 paf 269: uchar marker;
270: uchar code;
271: uchar length[2];
1.1 paf 272: };
1.21 paf 273: /// JPEG frame header
1.31 parser 274: struct JPG_Size_segment_body {
1.27 parser 275: char data; //< data precision of bits/sample
1.80 paf 276: uchar height[2]; //< image height
277: uchar width[2]; //< image width
1.27 parser 278: char numComponents; //< number of color components
1.1 paf 279: };
280:
1.79 paf 281: /// JPEG frame header
1.90.2.15.2.7 (paf 282:: struct JPG_Exif_segment_begin {
1.79 paf 283: char signature[6]; // Exif\0\0
284: };
285:
1.80 paf 286: /// JPEG Exif TIFF Header
287: struct JPG_Exif_TIFF_header {
288: uchar byte_align_identifier[2];
289: char dummy[2]; // always 000A [or 0A00]
290: uchar first_IFD_offset[4]; // Usually the first IFD starts immediately next to TIFF header, so this offset has value '0x00000008'.
291: };
292:
293: // JPEG Exif IFD start
1.90.2.15.2.7 (paf 294:: struct JPG_Exif_IFD_begin {
1.80 paf 295: uchar directory_entry_count[2]; // the number of directory entry contains in this IFD
296: };
297:
298: // TTTT ffff NNNNNNNN DDDDDDDD
299: struct JPG_Exif_IFD_entry {
300: uchar tag[2]; // Tag number, this shows a kind of data
301: uchar format[2]; // data format
302: uchar components_count[4]; // number of components
303: uchar value_or_offset_to_it[4]; // data value or offset to data value
304: };
305:
306: #define JPG_IFD_TAG_EXIF_OFFSET 0x8769
307:
1.89 paf 308: #define JPEG_EXIF_DATE_CHARS 20
309:
1.1 paf 310: //
311:
1.80 paf 312: inline ushort x_endian_to_ushort(uchar b0, uchar b1) {
313: return (ushort)((b1<<8) + b0);
1.33 parser 314: }
315:
1.80 paf 316: inline uint x_endian_to_uint(uchar b0, uchar b1, uchar b2, uchar b3) {
317: return (uint)(((((b3<<8) + b2)<<8)+b1)<<8)+b0;
1.33 parser 318: }
319:
1.80 paf 320: inline ushort endian_to_ushort(bool is_big, const uchar *b/* [2] */) {
321: return is_big?x_endian_to_ushort(b[1], b[0]):
322: x_endian_to_ushort(b[0], b[1]);
1.1 paf 323: }
324:
1.80 paf 325: inline uint endian_to_uint(bool is_big, const uchar *b /* [4] */) {
326: return is_big?x_endian_to_uint(b[3], b[2], b[1], b[0]):
327: x_endian_to_uint(b[0], b[1], b[2], b[3]);
328: }
329:
1.90.2.15.2.1 (paf 330:): static void measure_gif(const String& origin_string,
1.78 paf 331: Measure_reader& reader, ushort& width, ushort& height) {
1.1 paf 332:
1.90.2.15.2.5 (paf 333:: const char* buf;
1.1 paf 334: const int head_size=sizeof(GIF_Header);
335: if(reader.read(buf, head_size)<head_size)
1.68 paf 336: throw Exception("image.format",
1.90.2.15.2.1 (paf 337:): &origin_string,
1.34 parser 338: "not GIF file - too small");
1.31 parser 339: GIF_Header *head=(GIF_Header *)buf;
1.1 paf 340:
1.72 paf 341: if(strncmp(head->signature, "GIF", 3)!=0)
1.68 paf 342: throw Exception("image.format",
1.90.2.15.2.1 (paf 343:): &origin_string,
1.44 parser 344: "not GIF file - wrong signature");
1.1 paf 345:
1.80 paf 346: width=endian_to_ushort(false, head->width);
347: height=endian_to_ushort(false, head->height);
348: }
349:
1.90.2.15.2.8 (paf 350:: static Value* parse_IFD_entry_formatted_one_value(
1.80 paf 351: bool is_big,
352: ushort format,
353: size_t component_size,
354: const uchar *value) {
355: switch(format) {
356: case 1: // unsigned byte
1.90.2.15.2.1 (paf 357:): return new VInt((uchar)value[0]);
1.80 paf 358: case 3: // unsigned short
1.90.2.15.2.1 (paf 359:): return new VInt(endian_to_ushort(is_big, value));
1.80 paf 360: case 4: // unsigned long
361: // 'double' because parser's Int is signed
1.90.2.15.2.1 (paf 362:): return new VDouble(endian_to_uint(is_big, value));
1.80 paf 363: case 5: // unsigned rational
364: {
365: uint numerator=endian_to_uint(is_big, value); value+=component_size/2;
366: uint denominator=endian_to_uint(is_big, value);
367: if(!denominator)
1.90.2.15.2.8 (paf 368:: return 0;
1.90.2.15.2.1 (paf 369:): return new VDouble(((double)numerator)/denominator);
1.80 paf 370: }
371: case 6: // signed byte
1.90.2.15.2.1 (paf 372:): return new VInt((signed char)value[0]);
1.80 paf 373: case 8: // signed short
1.90.2.15.2.1 (paf 374:): return new VInt((signed short)endian_to_ushort(is_big, value));
1.80 paf 375: case 9: // signed long
1.90.2.15.2.1 (paf 376:): return new VInt((signed int)endian_to_uint(is_big, value));
1.80 paf 377: case 10: // signed rational
378: {
379: signed int numerator=(signed int)endian_to_uint(is_big, value); value+=component_size/2;
380: uint denominator=endian_to_uint(is_big, value);
381: if(!denominator)
1.90.2.15.2.8 (paf 382:: return 0;
1.90.2.15.2.1 (paf 383:): return new VDouble(numerator/denominator);
1.80 paf 384: }
385: /*
386: case 11: // single float
387: todo
388: case 12: // double float
389: todo
390: */
391: };
392:
1.90.2.15.2.8 (paf 393:: return 0;
1.80 paf 394: }
395:
1.89 paf 396: // date.C
1.90.2.15.2.1 (paf 397:): time_t cstr_to_time_t(char *cstr, bool fail_on_error);
1.89 paf 398:
1.90.2.15.2.8 (paf 399:: static Value* parse_IFD_entry_formatted_value(
1.80 paf 400: bool is_big, ushort format,
401: size_t component_size, uint components_count,
402: const uchar *value) {
403: if(format==2) { // ascii string, exception: the only type with varying size
1.90.2.3 paf 404: const char* cstr=(const char* )value;
1.80 paf 405: size_t size=components_count;
1.89 paf 406: // Data format is "YYYY:MM:DD HH:MM:SS"+0x00, total 20bytes
407: if(size==JPEG_EXIF_DATE_CHARS
408: && isdigit(cstr[0])
409: && cstr[JPEG_EXIF_DATE_CHARS-1]==0) {
410: char cstr_writable[JPEG_EXIF_DATE_CHARS];
411: strcpy(cstr_writable, cstr);
412:
1.90.2.8 paf 413: time_t t=cstr_to_time_t(cstr_writable,
1.90.2.15.2.1 (paf 414:: 0/* do not throw exception, just return bad result */);
1.89 paf 415: if(t>=0)
1.90.2.15.2.1 (paf 416:): return new VDate(t);
1.89 paf 417: }
418:
1.90.2.3 paf 419: if(const char* premature_zero_pos=(const char* )memchr(cstr, 0, size))
1.80 paf 420: size=premature_zero_pos-cstr;
1.90.2.15.2.1 (paf 421:): return new VString(*new String(cstr, size, true/*tainted*/));
1.80 paf 422: }
423:
424: if(components_count==1)
1.90.2.15.2.4 (paf 425:: return parse_IFD_entry_formatted_one_value(is_big, format, component_size, value);
1.80 paf 426:
1.90.2.15.2.1 (paf 427:): VHash* result=new VHash;
428:): HashStringValue& hash=result->hash();
1.80 paf 429: for(uint i=0; i<components_count; i++, value+=component_size) {
1.90.2.15.2.1 (paf 430:): hash.put(
431:): StringBody(pa_format_integer(i)),
1.90.2.15.2.4 (paf 432:: parse_IFD_entry_formatted_one_value(is_big, format, component_size, value));
1.80 paf 433: }
434:
1.90.2.7 paf 435: return result;
1.80 paf 436: }
437:
1.90.2.15.2.8 (paf 438:: static Value* parse_IFD_entry_value(
1.80 paf 439: bool is_big, Measure_reader& reader, long tiff_base,
440: JPG_Exif_IFD_entry& entry) {
441: size_t format2component_size[]={
442: 0, // undefined
443: 1, // unsigned byte
444: 1, // ascii string
445: 2, // unsigned short
446: 4, // unsigned long
447: 8, // unsigned rational
448: 1, // signed byte
449: 0, // undefined
450: 2, // signed short
451: 4, // signed long
452: 8, // signed rational
453: /*
454: 4, // single float
455: 8, // double float
456: */
457: };
458:
459: ushort format=endian_to_ushort(is_big, entry.format);
460: if(format>=sizeof(format2component_size)/sizeof(format2component_size[0]))
1.90.2.15.2.8 (paf 461:: return 0; // format out of range, ignoring
1.80 paf 462:
463: size_t component_size=format2component_size[format];
464: if(component_size==0)
1.90.2.15.2.8 (paf 465:: return 0; // undefined format
1.80 paf 466:
467: // You can get the total data byte length by multiplies
468: // a 'bytes/components' value (see above chart) by number of components stored 'NNNNNNNN' area
469: uint components_count=endian_to_uint(is_big, entry.components_count);
470: size_t value_size=component_size*components_count;
471: // If its size is over 4bytes, 'DDDDDDDD' contains the offset to data stored address
1.90.2.15.2.8 (paf 472:: Value* result;
1.80 paf 473:
474: if(value_size<=4)
1.90.2.15.2.1 (paf 475:): result=parse_IFD_entry_formatted_value(
1.80 paf 476: is_big, format,
477: component_size, components_count,
478: entry.value_or_offset_to_it);
479: else {
480: long remembered=reader.tell();
481: {
482: reader.seek(tiff_base+endian_to_uint(is_big, entry.value_or_offset_to_it), SEEK_SET);
1.90.2.15.2.5 (paf 483:: const char* value;
1.80 paf 484: if(reader.read(value, value_size)<sizeof(value_size))
1.90.2.15.2.8 (paf 485:: return 0;
1.90.2.15.2.1 (paf 486:): result=parse_IFD_entry_formatted_value(
1.80 paf 487: is_big, format,
488: component_size, components_count,
489: (const uchar*)value);
490: }
491: reader.seek(remembered, SEEK_SET);
492: }
493:
494: return result;
495: }
496:
1.90.2.15.2.1 (paf 497:): static void parse_IFD(HashStringValue& hash,
498:): bool is_big, Measure_reader& reader, long tiff_base);
1.80 paf 499:
1.90.2.15.2.1 (paf 500:): static void parse_IFD_entry(HashStringValue& hash,
501:): bool is_big, Measure_reader& reader, long tiff_base,
502:): JPG_Exif_IFD_entry& entry) {
1.80 paf 503: ushort tag=endian_to_ushort(is_big, entry.tag);
504: if(tag==JPG_IFD_TAG_EXIF_OFFSET) {
505: long remembered=reader.tell();
506: {
507: reader.seek(tiff_base+endian_to_uint(is_big, entry.value_or_offset_to_it), SEEK_SET);
1.90.2.15.2.4 (paf 508:: parse_IFD(hash, is_big, reader, tiff_base);
1.80 paf 509: }
510: reader.seek(remembered, SEEK_SET);
511: return;
512: }
513:
1.90.2.15.2.8 (paf 514:: if(Value* value=parse_IFD_entry_value(is_big, reader, tiff_base, entry)) {
1.90.2.13 paf 515: if(const char* name=exif_tag_value2name.get(tag))
1.90.2.15.2.1 (paf 516:): hash.put(StringBody(name), value);
517:): else
518:): hash.put(StringBody(pa_format_integer(tag)), value);
1.80 paf 519: }
1.1 paf 520: }
521:
1.90.2.15.2.1 (paf 522:: static void parse_IFD(
523:): HashStringValue& hash,
524:): bool is_big, Measure_reader& reader, long tiff_base) {
1.90.2.15.2.5 (paf 525:: const char* buf;
1.90.2.15.2.7 (paf 526:: if(reader.read(buf, sizeof(JPG_Exif_IFD_begin))<sizeof(JPG_Exif_IFD_begin))
1.80 paf 527: return;
1.90.2.15.2.7 (paf 528:: JPG_Exif_IFD_begin *start=(JPG_Exif_IFD_begin *)buf;
1.80 paf 529:
530: ushort directory_entry_count=endian_to_ushort(is_big, start->directory_entry_count);
531: for(int i=0; i<directory_entry_count; i++) {
532: if(reader.read(buf, sizeof(JPG_Exif_IFD_entry))<sizeof(JPG_Exif_IFD_entry))
533: return;
534:
1.90.2.15.2.4 (paf 535:: parse_IFD_entry(hash, is_big, reader, tiff_base, *(JPG_Exif_IFD_entry *)buf);
1.80 paf 536: }
537: // then goes: LLLLLLLL Offset to next IFD [not going there]
538: }
539:
1.90.2.15.2.1 (paf 540:): static Value* parse_exif(Measure_reader& reader, const String& origin_string) {
1.90.2.15.2.5 (paf 541:: const char* buf;
1.90.2.15.2.7 (paf 542:: if(reader.read(buf, sizeof(JPG_Exif_segment_begin))<sizeof(JPG_Exif_segment_begin))
1.80 paf 543: throw Exception("image.format",
1.90.2.15.2.1 (paf 544:): &origin_string,
1.80 paf 545: "not JPEG file - can not fully read Exif segment start");
546:
1.90.2.15.2.7 (paf 547:: JPG_Exif_segment_begin *start=(JPG_Exif_segment_begin *)buf;
1.80 paf 548: if(memcmp(start->signature, "Exif\0\0", 4+2)!=0) //signature invalid?
1.90.2.15.2.8 (paf 549:: return 0; // ignore invalid block
1.80 paf 550:
551: uint tiff_base=reader.tell();
552: if(reader.read(buf, sizeof(JPG_Exif_TIFF_header))<sizeof(JPG_Exif_TIFF_header))
1.90.2.15.2.8 (paf 553:: return 0;
1.80 paf 554:
555: JPG_Exif_TIFF_header *head=(JPG_Exif_TIFF_header *)buf;
556: bool is_big=head->byte_align_identifier[0]=='M'; // [M]otorola vs [I]ntel
557:
558: uint first_IFD_offset=endian_to_uint(is_big, head->first_IFD_offset);
559: reader.seek(tiff_base+first_IFD_offset, SEEK_SET);
560:
1.90.2.15.2.1 (paf 561:): VHash* vhash=new VHash;
1.80 paf 562:
563: // IFD
1.90.2.15.2.1 (paf 564:): parse_IFD(vhash->hash(), is_big, reader, tiff_base);
1.80 paf 565:
1.90.2.7 paf 566: return vhash;
1.80 paf 567: }
568:
1.90.2.15.2.1 (paf 569:): static void measure_jpeg(const String& origin_string,
1.90.2.15.2.8 (paf 570:: Measure_reader& reader, ushort& width, ushort& height, Value** exif) {
1.2 paf 571: // JFIF format markers
1.80 paf 572: const uchar MARKER=0xFF;
573: const uchar CODE_SIZE_A=0xC0;
574: const uchar CODE_SIZE_B=0xC1;
575: const uchar CODE_SIZE_C=0xC2;
576: const uchar CODE_SIZE_D=0xC3;
577: const uchar CODE_EXIF=0xE1;
1.2 paf 578:
1.90.2.15.2.5 (paf 579:: const char* buf;
1.18 paf 580: const size_t prefix_size=2;
1.31 parser 581: if(reader.read(buf, prefix_size)<prefix_size)
1.68 paf 582: throw Exception("image.format",
1.90.2.15.2.1 (paf 583:): &origin_string,
1.34 parser 584: "not JPEG file - too small");
1.80 paf 585: uchar *signature=(uchar *)buf;
1.1 paf 586:
1.31 parser 587: if(!(signature[0]==0xFF && signature[1]==0xD8))
1.68 paf 588: throw Exception("image.format",
1.90.2.15.2.1 (paf 589:): &origin_string,
1.44 parser 590: "not JPEG file - wrong signature");
1.31 parser 591:
592: while(true) {
1.80 paf 593: uint segment_base=reader.tell()+2/*marker,code*/;
1.31 parser 594: if(reader.read(buf, sizeof(JPG_Segment_head))<sizeof(JPG_Segment_head))
1.79 paf 595: break;
1.31 parser 596: JPG_Segment_head *head=(JPG_Segment_head *)buf;
597:
598: // Verify that it's a valid segment.
599: if(head->marker!=MARKER)
1.79 paf 600: throw Exception("image.format",
1.90.2.15.2.1 (paf 601:): &origin_string,
1.79 paf 602: "not JPEG file - marker not found");
603:
604: switch(head->code) {
605: // http://www.ba.wakwak.com/~tsuruzoh/Computer/Digicams/exif-e.html
606: case CODE_EXIF:
1.80 paf 607: if(exif && !*exif) // seen .jpg with some xml under EXIF tag, after real exif block :)
1.90.2.15.2.4 (paf 608:: *exif=parse_exif(reader, origin_string);
1.1 paf 609: break;
1.31 parser 610:
1.79 paf 611: case CODE_SIZE_A:
612: case CODE_SIZE_B:
613: case CODE_SIZE_C:
614: case CODE_SIZE_D:
615: {
616: // Segments that contain size info
617: if(reader.read(buf, sizeof(JPG_Size_segment_body))<sizeof(JPG_Size_segment_body))
618: throw Exception("image.format",
1.90.2.15.2.1 (paf 619:): &origin_string,
1.79 paf 620: "not JPEG file - can not fully read Size segment");
621: JPG_Size_segment_body *body=(JPG_Size_segment_body *)buf;
622:
1.80 paf 623: width=endian_to_ushort(true, body->width);
624: height=endian_to_ushort(true, body->height);
1.79 paf 625: }
1.80 paf 626: return;
1.79 paf 627: };
628:
1.80 paf 629: reader.seek(segment_base+endian_to_ushort(true, head->length), SEEK_SET);
1.31 parser 630: }
631:
1.79 paf 632: throw Exception("image.format",
1.90.2.15.2.1 (paf 633:): &origin_string,
1.79 paf 634: "broken JPEG file - size frame not found");
1.1 paf 635: }
636:
1.90.2.15.2.1 (paf 637:): static void measure_png(const String& origin_string,
1.78 paf 638: Measure_reader& reader, ushort& width, ushort& height) {
1.72 paf 639:
1.90.2.15.2.5 (paf 640:: const char* buf;
1.72 paf 641: const int head_size=sizeof(PNG_Header);
642: if(reader.read(buf, head_size)<head_size)
643: throw Exception("image.format",
1.90.2.15.2.1 (paf 644:): &origin_string,
1.72 paf 645: "not PNG file - too small");
646: PNG_Header *head=(PNG_Header *)buf;
647:
648: if(strncmp(head->signature, "IHDR", 4)!=0)
649: throw Exception("image.format",
1.90.2.15.2.1 (paf 650:): &origin_string,
1.72 paf 651: "not PNG file - wrong signature");
652:
1.80 paf 653: width=endian_to_ushort(true, head->width);
654: height=endian_to_ushort(true, head->height);
1.72 paf 655: }
656:
1.1 paf 657: // measure center
658:
1.90.2.15.2.1 (paf 659:): static void measure(const String& file_name,
1.90.2.15.2.8 (paf 660:: Measure_reader& reader, ushort& width, ushort& height, Value** exif) {
1.90.2.15.2.1 (paf 661:): const char* file_name_cstr=file_name.cstr(String::L_FILE_SPEC);
1.90.2.7 paf 662: if(const char* cext=strrchr(file_name_cstr, '.')) {
1.1 paf 663: cext++;
664: if(strcasecmp(cext, "GIF")==0)
1.90.2.15.2.4 (paf 665:: measure_gif(file_name, reader, width, height);
1.1 paf 666: else if(strcasecmp(cext, "JPG")==0 || strcasecmp(cext, "JPEG")==0)
1.90.2.15.2.4 (paf 667:: measure_jpeg(file_name, reader, width, height, exif);
1.72 paf 668: else if(strcasecmp(cext, "PNG")==0)
1.90.2.15.2.4 (paf 669:: measure_png(file_name, reader, width, height);
1.1 paf 670: else
1.68 paf 671: throw Exception("image.format",
1.90.2.15.2.1 (paf 672:): &file_name,
1.1 paf 673: "unhandled image file name extension '%s'", cext);
674: } else
1.68 paf 675: throw Exception("image.format",
1.90.2.15.2.1 (paf 676:): &file_name,
1.1 paf 677: "can not determine image type - no file name extension");
678: }
679:
1.77 paf 680: // methods
1.1 paf 681:
1.40 parser 682: #ifndef DOXYGEN
1.77 paf 683: struct File_measure_action_info {
1.90.2.7 paf 684: ushort* width;
685: ushort* height;
1.90.2.15.2.8 (paf 686:: Value** exif;
1.90.2.15.2.1 (paf 687:): const String* file_name;
1.1 paf 688: };
1.40 parser 689: #endif
1.90.2.15.2.1 (paf 690:: static void file_measure_action(
1.80 paf 691: struct stat& finfo, int f,
1.90.2.15.2.1 (paf 692:: const String& file_spec, const char* fname, bool as_text,
1.77 paf 693: void *context) {
694: File_measure_action_info& info=*static_cast<File_measure_action_info *>(context);
1.1 paf 695:
1.90.2.15.2.1 (paf 696:): Measure_file_reader reader(f, *info.file_name, fname);
697:): measure(*info.file_name, reader, *info.width, *info.height, info.exif);
1.1 paf 698: }
699:
1.90.2.15.2.1 (paf 700:): static void _measure(Request& r, MethodParams* params) {
701:): Value& data=params->as_no_junction(0, "data must not be code");
1.1 paf 702:
1.78 paf 703: ushort width=0;
704: ushort height=0;
1.90.2.15.2.1 (paf 705:): Value* exif=0;
706:): const String* file_name;
707:): if(file_name=data.get_string()) {
1.90.2.7 paf 708: File_measure_action_info info;
709: info.width=&width;
710: info.height=&height;
711: info.exif=&exif;
712: info.file_name=file_name;
1.90.2.15.2.1 (paf 713:): file_read_action_under_lock(r.absolute(*file_name),
1.77 paf 714: "measure", file_measure_action, &info);
1.1 paf 715: } else {
1.90.2.15.2.1 (paf 716:): VFile* vfile=data.as_vfile();
717:): file_name=&vfile->fields().get(name_name)->as_string();
1.77 paf 718: Measure_buf_reader reader(
1.90.2.7 paf 719: vfile->value_ptr(),
720: vfile->value_size(),
1.90.2.15.2.1 (paf 721:): *file_name
1.77 paf 722: );
1.90.2.15.2.1 (paf 723:): measure(*file_name, reader, width, height, &exif);
1.1 paf 724: }
725:
1.90.2.15.2.1 (paf 726:): GET_SELF(r, VImage).set(file_name, width, height, 0, exif);
1.1 paf 727: }
728:
1.40 parser 729: #ifndef DOXYGEN
1.4 paf 730: struct Attrib_info {
1.90.2.7 paf 731: String* tag; ///< html tag being constructed
732: HashStringValue* skip; ///< tag attributes not to append to tag string [to skip]
1.4 paf 733: };
1.40 parser 734: #endif
1.90.2.7 paf 735: static void append_attrib_pair(
1.90.2.15.2.1 (paf 736:): HashStringValue::key_type key,
737:): HashStringValue::value_type value,
738:): Attrib_info* info) {
1.49 parser 739: // skip user-specified and internal(starting with "line-") attributes
1.90.2.15.2.1 (paf 740:): if(info->skip && info->skip->get(key) || key.pos("line-")==0)
1.4 paf 741: return;
742:
1.3 paf 743: // src="a.gif" width=123 ismap[=-1]
1.90.2.7 paf 744: *info->tag << " " << key;
745: if(value->is_string() || value->as_int()>=0)
1.90.2.15.2.1 (paf 746:): *info->tag << "=\"" << value->as_string() << "\"";
1.3 paf 747: }
1.90.2.15.2.1 (paf 748:): static void _html(Request& r, MethodParams* params) {
1.3 paf 749:
1.90.2.7 paf 750: String tag;
1.3 paf 751: tag << "<img";
1.4 paf 752:
1.90.2.7 paf 753: const HashStringValue& fields=GET_SELF(r, VImage).fields();
754: HashStringValue* attribs=0;
1.4 paf 755:
1.90.2.10 paf 756: if(params->count()) {
1.69 paf 757: // for backward compatibility: someday was ^html{}
1.90.2.15.2.1 (paf 758:): Value& vattribs=r.process_to_value(*(*params)[0],
1.70 paf 759: /*0/*no name* /,*/
1.52 parser 760: false/*don't intercept string*/);
1.90.2.15.2.1 (paf 761:): if(!vattribs.is_string()) // allow empty
762:): if(attribs=vattribs.get_hash()) {
763:): Attrib_info info={&tag};
1.90.2.7 paf 764: attribs->for_each(append_attrib_pair, &info);
1.39 parser 765: } else
1.68 paf 766: throw Exception("parser.runtime",
1.90.2.15.2.1 (paf 767:): 0,
1.39 parser 768: "attributes must be hash");
769: }
1.4 paf 770:
1.90.2.7 paf 771: {
1.90.2.15.2.1 (paf 772:): Attrib_info info={&tag, attribs};
1.90.2.7 paf 773: fields.for_each(append_attrib_pair, &info);
774: }
1.6 paf 775: tag << " />";
1.3 paf 776: r.write_pass_lang(tag);
777: }
1.8 paf 778:
1.68 paf 779: /// @test wrap FILE to auto-object
1.90.2.15.2.1 (paf 780:): static gdImage* load(Request& r,
781:: const String& file_name){
1.16 paf 782:
1.90.2.15.2.1 (paf 783:): const char* file_name_cstr=r.absolute(file_name).cstr(String::L_FILE_SPEC);
1.16 paf 784: if(FILE *f=fopen(file_name_cstr, "rb")) {
1.90.2.15.2.1 (paf 785:): gdImage* image=new gdImage;
1.90.2.7 paf 786: bool ok=image->CreateFromGif(f);
1.16 paf 787: fclose(f);
1.23 paf 788: if(!ok)
1.68 paf 789: throw Exception("image.format",
1.90.2.15.2.1 (paf 790:): &file_name,
1.23 paf 791: "is not in GIF format");
1.90.2.7 paf 792: return image;
1.16 paf 793: } else {
1.68 paf 794: throw Exception("file.missing",
1.90.2.15.2.1 (paf 795:): 0,
796:): "can not open '%s'", file_name_cstr);
797:): return 0;
1.16 paf 798: }
799: }
800:
801:
1.90.2.15.2.1 (paf 802:): static void _load(Request& r, MethodParams* params) {
803:: const String& file_name=params->as_string(0, "file name must not be code");
1.6 paf 804:
1.90.2.15.2.1 (paf 805:): gdImage* image=load(r, file_name);
806:): GET_SELF(r, VImage).set(&file_name, image->SX(), image->SY(), image);
1.6 paf 807: }
808:
1.90.2.15.2.1 (paf 809:): static void _create(Request& r, MethodParams* params) {
1.6 paf 810:
1.90.2.10 paf 811: int width=params->as_int(0, "width must be int", r);
812: int height=params->as_int(1, "height must be int", r);
1.8 paf 813: int bgcolor_value=0xffFFff;
1.90.2.10 paf 814: if(params->count()>2)
815: bgcolor_value=params->as_int(2, "color must be int", r);
1.90.2.15.2.1 (paf 816:): gdImage* image=new gdImage;
1.90.2.7 paf 817: image->Create(width, height);
818: image->FilledRectangle(0, 0, width-1, height-1, image->Color(bgcolor_value));
1.90.2.15.2.1 (paf 819:: GET_SELF(r, VImage).set(0, width, height, image);
1.6 paf 820: }
821:
1.90.2.15.2.1 (paf 822:): static void _gif(Request& r, MethodParams* params) {
1.6 paf 823:
1.90.2.15.2.8 (paf 824:: gdImage* image=GET_SELF(r, VImage).image;
1.8 paf 825: if(!image)
1.68 paf 826: throw Exception(0,
1.90.2.15.2.1 (paf 827:): 0,
1.12 paf 828: "does not contain an image");
1.6 paf 829:
830: // could _ but don't thing it's wise to use $image.src for vfile.name
1.10 paf 831:
1.90.2.15.2.1 (paf 832:): gdBuf buf=image->Gif();
1.6 paf 833:
1.90.2.15.2.1 (paf 834:): VFile& vfile=*new VFile;
835:): Value* content_type=new VString(*new String("image/gif"));
836:): vfile.set(false/*not tainted*/,
837:): (const char*)buf.ptr, buf.size, 0, content_type);
1.6 paf 838:
839: r.write_no_lang(vfile);
840: }
841:
1.90.2.15.2.1 (paf 842:): static void _line(Request& r, MethodParams* params) {
1.12 paf 843:
1.90.2.15.2.8 (paf 844:: gdImage* image=GET_SELF(r, VImage).image;
1.12 paf 845: if(!image)
1.68 paf 846: throw Exception(0,
1.90.2.15.2.1 (paf 847:): 0,
1.12 paf 848: "does not contain an image");
849:
850: image->Line(
1.90.2.10 paf 851: params->as_int(0, "x0 must be int", r),
852: params->as_int(1, "y0 must be int", r),
853: params->as_int(2, "x1 must be int", r),
854: params->as_int(3, "y1 must be int", r),
855: image->Color(params->as_int(4, "color must be int", r)));
1.13 paf 856: }
857:
1.90.2.15.2.1 (paf 858:): static void _fill(Request& r, MethodParams* params) {
1.13 paf 859:
1.90.2.15.2.8 (paf 860:: gdImage* image=GET_SELF(r, VImage).image;
1.13 paf 861: if(!image)
1.68 paf 862: throw Exception(0,
1.90.2.15.2.1 (paf 863:): 0,
1.13 paf 864: "does not contain an image");
1.12 paf 865:
1.13 paf 866: image->Fill(
1.90.2.10 paf 867: params->as_int(0, "x must be int", r),
868: params->as_int(1, "y must be int", r),
869: image->Color(params->as_int(2, "color must be int", r)));
1.13 paf 870: }
871:
1.90.2.15.2.1 (paf 872:): static void _rectangle(Request& r, MethodParams* params) {
1.13 paf 873:
1.90.2.15.2.8 (paf 874:: gdImage* image=GET_SELF(r, VImage).image;
1.13 paf 875: if(!image)
1.68 paf 876: throw Exception(0,
1.90.2.15.2.1 (paf 877:): 0,
1.13 paf 878: "does not contain an image");
879:
880: image->Rectangle(
1.90.2.10 paf 881: params->as_int(0, "x0 must be int", r),
882: params->as_int(1, "y0 must be int", r),
883: params->as_int(2, "x1 must be int", r),
884: params->as_int(3, "y1 must be int", r),
885: image->Color(params->as_int(4, "color must be int", r)));
1.13 paf 886: }
887:
1.90.2.15.2.1 (paf 888:): static void _bar(Request& r, MethodParams* params) {
1.13 paf 889:
1.90.2.15.2.8 (paf 890:: gdImage* image=GET_SELF(r, VImage).image;
1.13 paf 891: if(!image)
1.68 paf 892: throw Exception(0,
1.90.2.15.2.1 (paf 893:): 0,
1.13 paf 894: "does not contain an image");
895:
896: image->FilledRectangle(
1.90.2.10 paf 897: params->as_int(0, "x0 must be int", r),
898: params->as_int(1, "y0 must be int", r),
899: params->as_int(2, "x1 must be int", r),
900: params->as_int(3, "y1 must be int", r),
901: image->Color(params->as_int(4, "color must be int", r)));
1.13 paf 902: }
903:
1.44 parser 904: #ifndef DOXYGEN
1.90.2.7 paf 905: static void add_point(Table::element_type row,
906: gdImage::Point **p) {
907: (**p).x=row->get(0)->as_int();
908: (**p).y=row->get(1)->as_int();
1.44 parser 909: (*p)++;
910: }
911: #endif
1.90.2.15.2.1 (paf 912:): static void _replace(Request& r, MethodParams* params) {
1.13 paf 913:
1.90.2.15.2.8 (paf 914:: gdImage* image=GET_SELF(r, VImage).image;
1.13 paf 915: if(!image)
1.68 paf 916: throw Exception(0,
1.90.2.15.2.1 (paf 917:): 0,
1.13 paf 918: "does not contain an image");
919:
1.90.2.15.2.1 (paf 920:): Table* table=params->as_no_junction(2, "coordinates must not be code").get_table();
1.44 parser 921: if(!table)
1.68 paf 922: throw Exception(0,
1.90.2.15.2.1 (paf 923:): 0,
1.44 parser 924: "coordinates must be table");
1.13 paf 925:
1.90.2.15.2.1 (paf 926:: gdImage::Point *all_p=new gdImage::Point[table->count()];
1.44 parser 927: gdImage::Point *add_p=all_p;
928: table->for_each(add_point, &add_p);
1.90.2.7 paf 929: image->FilledPolygonReplaceColor(all_p, table->count(),
1.90.2.10 paf 930: image->Color(params->as_int(0, "src color must be int", r)),
931: image->Color(params->as_int(1, "dest color must be int", r)));
1.13 paf 932: }
933:
1.90.2.15.2.1 (paf 934:): static void _polyline(Request& r, MethodParams* params) {
1.13 paf 935:
1.90.2.15.2.8 (paf 936:: gdImage* image=GET_SELF(r, VImage).image;
1.13 paf 937: if(!image)
1.68 paf 938: throw Exception(0,
1.90.2.15.2.1 (paf 939:): 0,
1.13 paf 940: "does not contain an image");
941:
1.90.2.15.2.1 (paf 942:): Table* table=params->as_no_junction(1, "coordinates must not be code").get_table();
1.44 parser 943: if(!table)
1.68 paf 944: throw Exception(0,
1.90.2.15.2.1 (paf 945:): 0,
1.44 parser 946: "coordinates must be table");
947:
1.90.2.15.2.1 (paf 948:: gdImage::Point* all_p=new gdImage::Point[table->count()];
1.44 parser 949: gdImage::Point *add_p=all_p;
950: table->for_each(add_point, &add_p);
1.90.2.7 paf 951: image->Polygon(all_p, table->count(),
1.90.2.10 paf 952: image->Color(params->as_int(0, "color must be int", r)),
1.44 parser 953: false/*not closed*/);
954: }
955:
1.90.2.15.2.1 (paf 956:): static void _polygon(Request& r, MethodParams* params) {
1.44 parser 957:
1.90.2.15.2.8 (paf 958:: gdImage* image=GET_SELF(r, VImage).image;
1.44 parser 959: if(!image)
1.68 paf 960: throw Exception(0,
1.90.2.15.2.1 (paf 961:): 0,
1.44 parser 962: "does not contain an image");
1.13 paf 963:
1.90.2.15.2.1 (paf 964:): Table* table=params->as_no_junction(1, "coordinates must not be code").get_table();
1.44 parser 965: if(!table)
1.68 paf 966: throw Exception(0,
1.90.2.15.2.1 (paf 967:): 0,
1.44 parser 968: "coordinates must be table");
969:
1.90.2.15.2.1 (paf 970:: gdImage::Point* all_p=new gdImage::Point[table->count()];
1.44 parser 971: gdImage::Point *add_p=all_p;
972: table->for_each(add_point, &add_p);
1.90.2.7 paf 973: image->Polygon(all_p, table->count(),
1.90.2.10 paf 974: image->Color(params->as_int(0, "color must be int", r)));
1.13 paf 975: }
976:
1.90.2.15.2.1 (paf 977:): static void _polybar(Request& r, MethodParams* params) {
1.13 paf 978:
1.90.2.15.2.8 (paf 979:: gdImage* image=GET_SELF(r, VImage).image;
1.13 paf 980: if(!image)
1.68 paf 981: throw Exception(0,
1.90.2.15.2.1 (paf 982:): 0,
1.13 paf 983: "does not contain an image");
984:
1.90.2.15.2.1 (paf 985:): Table* table=params->as_no_junction(1, "coordinates must not be code").get_table();
1.44 parser 986: if(!table)
1.68 paf 987: throw Exception("parser.runtime",
1.90.2.15.2.1 (paf 988:): 0,
1.44 parser 989: "coordinates must be table");
1.13 paf 990:
1.90.2.15.2.1 (paf 991:: gdImage::Point* all_p=new gdImage::Point[table->count()];
1.44 parser 992: gdImage::Point *add_p=all_p;
993: table->for_each(add_point, &add_p);
1.90.2.7 paf 994: image->FilledPolygon(all_p, table->count(),
1.90.2.10 paf 995: image->Color(params->as_int(0, "color must be int", r)));
1.12 paf 996: }
997:
1.16 paf 998: // font
999:
1.85 paf 1000: #define Y(y)(y+index*height)
1.21 paf 1001:
1.90.2.15 paf 1002: // Font class
1003:
1004: const int Font::letter_spacing=1;
1005:
1.90.2.15.2.1 (paf 1006:: Font::Font(//,
1007:: const String& aalphabet,
1.90.2.15.2.8 (paf 1008:: gdImage* aifont, int aheight, int amonospace, int aspacebarspace):
1.90.2.15 paf 1009: alphabet(aalphabet),
1010: height(aheight), monospace(amonospace), spacebarspace(aspacebarspace),
1011: ifont(aifont) {
1012: }
1013:
1014: /* ******************************** char ********************************** */
1.87 paf 1015:
1.90.2.15.2.1 (paf 1016:): size_t Font::index_of(char ch) {
1017:): if(ch==' ') return STRING_NOT_FOUND;
1018:): return alphabet.pos(&ch, 1);
1.90.2.15 paf 1019: }
1020:
1.90.2.15.2.1 (paf 1021:): int Font::index_width(size_t index) {
1022:): if(index==STRING_NOT_FOUND)
1.90.2.15 paf 1023: return spacebarspace;
1024: int tr=ifont->GetTransparent();
1025: for(int x=ifont->SX()-1; x>=0; x--) {
1026: for(int y=0; y<height; y++)
1027: if(ifont->GetPixel(x, Y(y))!=tr)
1028: return x+1;
1.16 paf 1029: }
1.90.2.15 paf 1030: return 0;
1031: }
1032:
1.90.2.15.2.1 (paf 1033:): void Font::index_display(gdImage* image, int x, int y, size_t index){
1034:): if(index!=STRING_NOT_FOUND)
1.90.2.15 paf 1035: ifont->Copy(*image, x, y, 0, Y(0), index_width(index), height);
1036: }
1037:
1038: /* ******************************** string ********************************** */
1039:
1040: int Font::step_width(int index) {
1041: return letter_spacing + (monospace ? monospace : index_width(index));
1042: }
1043:
1044: // counts trailing letter_spacing, consider this OK. useful for contiuations
1.90.2.15.2.1 (paf 1045:: int Font::string_width(const String& s){
1046:): const char* cstr=s.cstr();
1.90.2.15 paf 1047: int result=0;
1048: for(const char* current=cstr; *current; current++)
1049: result+=step_width(index_of(*current));
1050: return result;
1051: }
1052:
1.90.2.15.2.8 (paf 1053:: void Font::string_display(gdImage* image, int x, int y, const String& s){
1.90.2.15.2.1 (paf 1054:): const char* cstr=s.cstr();
1.90.2.15 paf 1055: for(const char* current=cstr; *current; current++) {
1.90.2.15.2.1 (paf 1056:): size_t index=index_of(*current);
1.90.2.15 paf 1057: index_display(image, x, y, index);
1058: x+=step_width(index);
1.16 paf 1059: }
1.90.2.15 paf 1060: }
1061:
1062: //
1063:
1.35 parser 1064:
1.90.2.15.2.1 (paf 1065:): static void _font(Request& r, MethodParams* params) {
1.16 paf 1066:
1.90.2.15.2.1 (paf 1067:: const String& alphabet=params->as_string(0, "alphabet must not be code");
1068:): gdImage* image=load(r, params->as_string(1, "file_name must not be code"));
1.90.2.10 paf 1069: int spacebar_width=params->as_int(2, "spacebar_width must be int", r);
1.37 parser 1070: int monospace_width;
1.90.2.10 paf 1071: if(params->count()>3) {
1072: monospace_width=params->as_int(3, "monospace_width must be int", r);
1.37 parser 1073: if(!monospace_width)
1.90.2.7 paf 1074: monospace_width=image->SX();
1.37 parser 1075: } else
1076: monospace_width=0;
1.16 paf 1077:
1.90.2.15.2.1 (paf 1078:): if(!alphabet.length())
1.68 paf 1079: throw Exception("parser.runtime",
1.90.2.15.2.1 (paf 1080:): 0,
1.37 parser 1081: "alphabet must not be empty");
1.84 paf 1082:
1.90.2.15.2.1 (paf 1083:): if(int remainder=image->SY() % alphabet.length())
1.84 paf 1084: throw Exception("parser.runtime",
1.90.2.15.2.1 (paf 1085:): 0,
1.84 paf 1086: "font-file height(%d) not divisable by alphabet size(%d), remainder=%d",
1.90.2.15.2.1 (paf 1087:): image->SY(), alphabet.length(), remainder);
1.37 parser 1088:
1.90.2.15.2.1 (paf 1089:): GET_SELF(r, VImage).font=new Font(
1.37 parser 1090: alphabet,
1.36 parser 1091: image,
1.90.2.15.2.1 (paf 1092:): image->SY() / alphabet.length(), monospace_width, spacebar_width);
1.16 paf 1093: }
1094:
1.90.2.15.2.1 (paf 1095:): static void _text(Request& r, MethodParams* params) {
1.16 paf 1096:
1.90.2.10 paf 1097: int x=params->as_int(0, "x must be int", r);
1098: int y=params->as_int(1, "y must be int", r);
1.90.2.15.2.1 (paf 1099:: const String& s=params->as_string(2, "text must not be code");
1.16 paf 1100:
1.90.2.7 paf 1101: VImage& vimage=GET_SELF(r, VImage);
1.16 paf 1102: if(vimage.image)
1103: if(vimage.font)
1.90.2.7 paf 1104: vimage.font->string_display(vimage.image, x, y, s);
1.16 paf 1105: else
1.68 paf 1106: throw Exception("parser.runtime",
1.90.2.15.2.1 (paf 1107:): 0,
1.16 paf 1108: "set the font first");
1109: else
1.68 paf 1110: throw Exception(0,
1.90.2.15.2.1 (paf 1111:): 0,
1.16 paf 1112: "does not contain an image");
1113: }
1114:
1.90.2.15.2.1 (paf 1115:): static void _length(Request& r, MethodParams* params) {
1.47 parser 1116:
1.90.2.15.2.1 (paf 1117:): const String& s=params->as_string(0, "text must not be code");
1.47 parser 1118:
1.90.2.7 paf 1119: VImage& vimage=GET_SELF(r, VImage);
1.47 parser 1120: if(vimage.image)
1121: if(vimage.font) {
1.90.2.15.2.1 (paf 1122:): r.write_no_lang(*new VInt(vimage.font->string_width(s)));
1.47 parser 1123: } else
1.68 paf 1124: throw Exception("parser.runtime",
1.90.2.15.2.1 (paf 1125:): 0,
1.47 parser 1126: "set the font first");
1127: else
1.68 paf 1128: throw Exception(0,
1.90.2.15.2.1 (paf 1129:): 0,
1.47 parser 1130: "does not contain an image");
1131: }
1132:
1.90.2.15.2.1 (paf 1133:): static void _arc(Request& r, MethodParams* params) {
1.48 parser 1134:
1.90.2.15.2.8 (paf 1135:: gdImage* image=GET_SELF(r, VImage).image;
1.48 parser 1136: if(!image)
1.68 paf 1137: throw Exception(0,
1.90.2.15.2.1 (paf 1138:): 0,
1.48 parser 1139: "does not contain an image");
1140:
1141: image->Arc(
1.90.2.10 paf 1142: params->as_int(0, "center_x must be int", r),
1143: params->as_int(1, "center_y must be int", r),
1144: params->as_int(2, "width must be int", r),
1145: params->as_int(3, "height must be int", r),
1146: params->as_int(4, "start degrees must be int", r),
1147: params->as_int(5, "end degrees must be int", r),
1148: image->Color(params->as_int(6, "cx must be int", r)));
1.48 parser 1149: }
1150:
1.90.2.15.2.1 (paf 1151:): static void _sector(Request& r, MethodParams* params) {
1.49 parser 1152:
1.90.2.15.2.8 (paf 1153:: gdImage* image=GET_SELF(r, VImage).image;
1.49 parser 1154: if(!image)
1.68 paf 1155: throw Exception(0,
1.90.2.15.2.1 (paf 1156:): 0,
1.49 parser 1157: "does not contain an image");
1158:
1159: image->Sector(
1.90.2.10 paf 1160: params->as_int(0, "center_x must be int", r),
1161: params->as_int(1, "center_y must be int", r),
1162: params->as_int(2, "width must be int", r),
1163: params->as_int(3, "height must be int", r),
1164: params->as_int(4, "start degrees must be int", r),
1165: params->as_int(5, "end degrees must be int", r),
1166: image->Color(params->as_int(6, "color must be int", r)));
1.49 parser 1167: }
1168:
1.90.2.15.2.1 (paf 1169:): static void _circle(Request& r, MethodParams* params) {
1.48 parser 1170:
1.90.2.15.2.8 (paf 1171:: gdImage* image=GET_SELF(r, VImage).image;
1.48 parser 1172: if(!image)
1.68 paf 1173: throw Exception(0,
1.90.2.15.2.1 (paf 1174:): 0,
1.48 parser 1175: "does not contain an image");
1176:
1.90.2.10 paf 1177: int size=params->as_int(2, "radius must be int", r)*2;
1.48 parser 1178: image->Arc(
1.90.2.10 paf 1179: params->as_int(0, "center_x must be int", r),
1180: params->as_int(1, "center_y must be int", r),
1.50 parser 1181: size, //w
1182: size, //h
1.48 parser 1183: 0, //s
1184: 360, //e
1.90.2.10 paf 1185: image->Color(params->as_int(3, "color must be int", r)));
1.48 parser 1186: }
1187:
1.90.2.15.2.1 (paf 1188:): gdImage* as_image(MethodParams* params, int index, const char* msg) {
1189:): gdImage* src=0;
1.75 paf 1190:
1.90.2.15.2.1 (paf 1191:): Value& value=params->as_no_junction(index, msg);
1.53 parser 1192:
1.90.2.15.2.1 (paf 1193:): if(Value* vimage=value.as(VIMAGE_TYPE, false)) {
1.75 paf 1194: src=static_cast<VImage *>(vimage)->image;
1195: if(!src)
1196: throw Exception("parser.runtime",
1.90.2.15.2.1 (paf 1197:): 0,
1.75 paf 1198: msg);
1199: } else
1.68 paf 1200: throw Exception("parser.runtime",
1.90.2.15.2.1 (paf 1201:): 0,
1.53 parser 1202: msg);
1203:
1.90.2.7 paf 1204: return src;
1.53 parser 1205: }
1206:
1.90.2.15.2.1 (paf 1207:): static void _copy(Request& r, MethodParams* params) {
1.53 parser 1208:
1.90.2.15.2.8 (paf 1209:: gdImage* dest=GET_SELF(r, VImage).image;
1.53 parser 1210: if(!dest)
1.68 paf 1211: throw Exception(0,
1.90.2.15.2.1 (paf 1212:): 0,
1.53 parser 1213: "self does not contain an image");
1214:
1.90.2.15.2.1 (paf 1215:): gdImage* src=as_image(params, 0, "src must be image");
1.53 parser 1216:
1.90.2.10 paf 1217: int sx=params->as_int(1, "src_x must be int", r);
1218: int sy=params->as_int(2, "src_y must be int", r);
1219: int sw=params->as_int(3, "src_w must be int", r);
1220: int sh=params->as_int(4, "src_h must be int", r);
1221: int dx=params->as_int(5, "dest_x must be int", r);
1222: int dy=params->as_int(6, "dest_y must be int", r);
1223: if(params->count()>1+2+2+2) {
1224: int dw=params->as_int(1+2+2+2, "dest_w must be int", r);
1225: int dh=(int)(params->count()>1+2+2+2+1?
1226: params->as_int(1+2+2+2+1, "dest_h must be int", r):sh*(((double)dw)/((double)sw)));
1227: int tolerance=params->count()>1+2+2+2+2?
1228: params->as_int(1+2+2+2+2, "tolerance must be int", r):150;
1.53 parser 1229:
1.90.2.7 paf 1230: src->CopyResampled(*dest, dx, dy, sx, sy, dw, dh, sw, sh, tolerance);
1.53 parser 1231: } else
1.90.2.7 paf 1232: src->Copy(*dest, dx, dy, sx, sy, sw, sh);
1.53 parser 1233: }
1234:
1235:
1.22 paf 1236: // constructor
1237:
1.90.2.7 paf 1238: MImage::MImage(): Methoded("image") {
1.1 paf 1239: // ^image:measure[DATA]
1.22 paf 1240: add_native_method("measure", Method::CT_DYNAMIC, _measure, 1, 1);
1.3 paf 1241:
1.25 paf 1242: // ^image.html[]
1243: // ^image.html[hash]
1.22 paf 1244: add_native_method("html", Method::CT_DYNAMIC, _html, 0, 1);
1.6 paf 1245:
1.25 paf 1246: // ^image.load[background.gif]
1.22 paf 1247: add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
1.6 paf 1248:
1.25 paf 1249: // ^image.create[width;height] bgcolor=white
1250: // ^image.create[width;height;bgcolor]
1.22 paf 1251: add_native_method("create", Method::CT_DYNAMIC, _create, 2, 3);
1.6 paf 1252:
1.25 paf 1253: // ^image.gif[]
1.22 paf 1254: add_native_method("gif", Method::CT_DYNAMIC, _gif, 0, 0);
1.12 paf 1255:
1.25 paf 1256: // ^image.line(x0;y0;x1;y1;color)
1.22 paf 1257: add_native_method("line", Method::CT_DYNAMIC, _line, 5, 5);
1.13 paf 1258:
1.25 paf 1259: // ^image.fill(x;y;color)
1.22 paf 1260: add_native_method("fill", Method::CT_DYNAMIC, _fill, 3, 3);
1.13 paf 1261:
1.25 paf 1262: // ^image.rectangle(x0;y0;x1;y1;color)
1.22 paf 1263: add_native_method("rectangle", Method::CT_DYNAMIC, _rectangle, 5, 5);
1.13 paf 1264:
1.25 paf 1265: // ^image.bar(x0;y0;x1;y1;color)
1.22 paf 1266: add_native_method("bar", Method::CT_DYNAMIC, _bar, 5, 5);
1.13 paf 1267:
1.44 parser 1268: // ^image.replace(color-source;color-dest)[table x:y]
1269: add_native_method("replace", Method::CT_DYNAMIC, _replace, 3, 3);
1270:
1271: // ^image.polyline(color)[table x:y]
1272: add_native_method("polyline", Method::CT_DYNAMIC, _polyline, 2, 2);
1.13 paf 1273:
1.44 parser 1274: // ^image.polygon(color)[table x:y]
1275: add_native_method("polygon", Method::CT_DYNAMIC, _polygon, 2, 2);
1.13 paf 1276:
1.44 parser 1277: // ^image.polybar(color)[table x:y]
1278: add_native_method("polybar", Method::CT_DYNAMIC, _polybar, 2, 2);
1.13 paf 1279:
1.36 parser 1280: // ^image.font[alPHAbet;font-file-name.gif](spacebar_width)
1281: // ^image.font[alPHAbet;font-file-name.gif](spacebar_width;width)
1282: add_native_method("font", Method::CT_DYNAMIC, _font, 3, 4);
1.16 paf 1283:
1.25 paf 1284: // ^image.text(x;y)[text]
1.22 paf 1285: add_native_method("text", Method::CT_DYNAMIC, _text, 3, 3);
1.47 parser 1286:
1287: // ^image.ngth[text]
1288: add_native_method("length", Method::CT_DYNAMIC, _length, 1, 1);
1.16 paf 1289:
1.48 parser 1290: // ^image.arc(center x;center y;width;height;start in degrees;end in degrees;color)
1291: add_native_method("arc", Method::CT_DYNAMIC, _arc, 7, 7);
1.49 parser 1292:
1293: // ^image.sector(center x;center y;width;height;start in degrees;end in degrees;color)
1294: add_native_method("sector", Method::CT_DYNAMIC, _sector, 7, 7);
1.48 parser 1295:
1296: // ^image.circle(center x;center y;r;color)
1297: add_native_method("circle", Method::CT_DYNAMIC, _circle, 4, 4);
1298:
1.56 parser 1299: // ^image.copy[source](src x;src y;src w;src h;dst x;dst y[;dest w[;dest h[;tolerance]]])
1300: add_native_method("copy", Method::CT_DYNAMIC, _copy, 1+2+2+2, (1+2+2+2)+2+1);
1.1 paf 1301: }
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to image.C CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / classes