]> Creatis software - clitk.git/blob - utilities/CxImage/ximaexif.cpp
Rolled back to middle slice on first load
[clitk.git] / utilities / CxImage / ximaexif.cpp
1 /*\r
2  * File:        ximaexif.cpp\r
3  * Purpose:     EXIF reader\r
4  * 18/Aug/2002 Davide Pizzolato - www.xdp.it\r
5  * CxImage version 6.0.0 02/Feb/2008\r
6  * based on jhead-1.8 by Matthias Wandel <mwandel(at)rim(dot)net>\r
7  */\r
8 \r
9 #include "ximajpg.h"\r
10 \r
11 #if CXIMAGEJPG_SUPPORT_EXIF\r
12 \r
13 ////////////////////////////////////////////////////////////////////////////////\r
14 CxImageJPG::CxExifInfo::CxExifInfo(EXIFINFO* info)\r
15 {\r
16         if (info) {\r
17                 m_exifinfo = info;\r
18                 freeinfo = false;\r
19         } else {\r
20                 m_exifinfo = new EXIFINFO;\r
21                 memset(m_exifinfo,0,sizeof(EXIFINFO));\r
22                 freeinfo = true;\r
23         }\r
24 \r
25         m_szLastError[0]='\0';\r
26         ExifImageWidth = MotorolaOrder = 0;\r
27         SectionsRead=0;\r
28         memset(&Sections, 0, MAX_SECTIONS * sizeof(Section_t));\r
29 }\r
30 ////////////////////////////////////////////////////////////////////////////////\r
31 CxImageJPG::CxExifInfo::~CxExifInfo()\r
32 {\r
33         for(int i=0;i<MAX_SECTIONS;i++) if(Sections[i].Data) free(Sections[i].Data);\r
34         if (freeinfo) delete m_exifinfo;\r
35 }\r
36 ////////////////////////////////////////////////////////////////////////////////\r
37 bool CxImageJPG::CxExifInfo::DecodeExif(CxFile * hFile, int nReadMode)\r
38 {\r
39     int a;\r
40     int HaveCom = FALSE;\r
41 \r
42     a = hFile->GetC();\r
43 \r
44     if (a != 0xff || hFile->GetC() != M_SOI){\r
45         return FALSE;\r
46     }\r
47 \r
48     for(;;){\r
49         int itemlen;\r
50         int marker = 0;\r
51         int ll,lh, got;\r
52         BYTE * Data;\r
53 \r
54         if (SectionsRead >= MAX_SECTIONS){\r
55                         strcpy(m_szLastError,"Too many sections in jpg file");\r
56                         return false;\r
57         }\r
58 \r
59         for (a=0;a<7;a++){\r
60             marker = hFile->GetC();\r
61             if (marker != 0xff) break;\r
62 \r
63             if (a >= 6){\r
64                 printf("too many padding bytes\n");\r
65                 return false;\r
66             }\r
67         }\r
68 \r
69         if (marker == 0xff){\r
70             // 0xff is legal padding, but if we get that many, something's wrong.\r
71             strcpy(m_szLastError,"too many padding bytes!");\r
72                         return false;\r
73         }\r
74 \r
75         Sections[SectionsRead].Type = marker;\r
76 \r
77         // Read the length of the section.\r
78         lh = hFile->GetC();\r
79         ll = hFile->GetC();\r
80 \r
81         itemlen = (lh << 8) | ll;\r
82 \r
83         if (itemlen < 2){\r
84             strcpy(m_szLastError,"invalid marker");\r
85                         return false;\r
86         }\r
87 \r
88         Sections[SectionsRead].Size = itemlen;\r
89 \r
90         Data = (BYTE *)malloc(itemlen);\r
91         if (Data == NULL){\r
92             strcpy(m_szLastError,"Could not allocate memory");\r
93                         return false;\r
94         }\r
95         Sections[SectionsRead].Data = Data;\r
96 \r
97         // Store first two pre-read bytes.\r
98         Data[0] = (BYTE)lh;\r
99         Data[1] = (BYTE)ll;\r
100 \r
101         got = hFile->Read(Data+2, 1, itemlen-2); // Read the whole section.\r
102         if (got != itemlen-2){\r
103             strcpy(m_szLastError,"Premature end of file?");\r
104                         return false;\r
105         }\r
106         SectionsRead += 1;\r
107 \r
108         switch(marker){\r
109 \r
110             case M_SOS:   // stop before hitting compressed data \r
111                 // If reading entire image is requested, read the rest of the data.\r
112                 if (nReadMode & EXIF_READ_IMAGE){\r
113                     int cp, ep, size;\r
114                     // Determine how much file is left.\r
115                     cp = hFile->Tell();\r
116                     hFile->Seek(0, SEEK_END);\r
117                     ep = hFile->Tell();\r
118                     hFile->Seek(cp, SEEK_SET);\r
119 \r
120                     size = ep-cp;\r
121                     Data = (BYTE *)malloc(size);\r
122                     if (Data == NULL){\r
123                         strcpy(m_szLastError,"could not allocate data for entire image");\r
124                                                 return false;\r
125                     }\r
126 \r
127                     got = hFile->Read(Data, 1, size);\r
128                     if (got != size){\r
129                         strcpy(m_szLastError,"could not read the rest of the image");\r
130                                                 return false;\r
131                     }\r
132 \r
133                     Sections[SectionsRead].Data = Data;\r
134                     Sections[SectionsRead].Size = size;\r
135                     Sections[SectionsRead].Type = PSEUDO_IMAGE_MARKER;\r
136                     SectionsRead ++;\r
137                 }\r
138                 return true;\r
139 \r
140             case M_EOI:   // in case it's a tables-only JPEG stream\r
141                 printf("No image in jpeg!\n");\r
142                 return FALSE;\r
143 \r
144             case M_COM: // Comment section\r
145                 if (HaveCom || ((nReadMode & EXIF_READ_EXIF) == 0)){\r
146                     // Discard this section.\r
147                     free(Sections[--SectionsRead].Data);\r
148                                         Sections[SectionsRead].Data=0;\r
149                 }else{\r
150                     process_COM(Data, itemlen);\r
151                     HaveCom = TRUE;\r
152                 }\r
153                 break;\r
154 \r
155             case M_JFIF:\r
156                 // Regular jpegs always have this tag, exif images have the exif\r
157                 // marker instead, althogh ACDsee will write images with both markers.\r
158                 // this program will re-create this marker on absence of exif marker.\r
159                 // hence no need to keep the copy from the file.\r
160                 free(Sections[--SectionsRead].Data);\r
161                                 Sections[SectionsRead].Data=0;\r
162                 break;\r
163 \r
164             case M_EXIF:\r
165                 // Seen files from some 'U-lead' software with Vivitar scanner\r
166                 // that uses marker 31 for non exif stuff.  Thus make sure \r
167                 // it says 'Exif' in the section before treating it as exif.\r
168                 if ((nReadMode & EXIF_READ_EXIF) && memcmp(Data+2, "Exif", 4) == 0){\r
169                     m_exifinfo->IsExif = process_EXIF((BYTE *)Data+2, itemlen);\r
170                 }else{\r
171                     // Discard this section.\r
172                     free(Sections[--SectionsRead].Data);\r
173                                         Sections[SectionsRead].Data=0;\r
174                 }\r
175                 break;\r
176 \r
177             case M_SOF0: \r
178             case M_SOF1: \r
179             case M_SOF2: \r
180             case M_SOF3: \r
181             case M_SOF5: \r
182             case M_SOF6: \r
183             case M_SOF7: \r
184             case M_SOF9: \r
185             case M_SOF10:\r
186             case M_SOF11:\r
187             case M_SOF13:\r
188             case M_SOF14:\r
189             case M_SOF15:\r
190                 process_SOFn(Data, marker);\r
191                 break;\r
192             default:\r
193                 // Skip any other sections.\r
194                 //if (ShowTags) printf("Jpeg section marker 0x%02x size %d\n",marker, itemlen);\r
195                 break;\r
196         }\r
197     }\r
198         return true;\r
199 }\r
200 ////////////////////////////////////////////////////////////////////////////////\r
201 /*--------------------------------------------------------------------------\r
202    Process a EXIF marker\r
203    Describes all the drivel that most digital cameras include...\r
204 --------------------------------------------------------------------------*/\r
205 bool CxImageJPG::CxExifInfo::process_EXIF(unsigned char * CharBuf, unsigned int length)\r
206 {\r
207     m_exifinfo->FlashUsed = 0; \r
208     /* If it's from a digicam, and it used flash, it says so. */\r
209     m_exifinfo->Comments[0] = '\0';  /* Initial value - null string */\r
210 \r
211     ExifImageWidth = 0;\r
212 \r
213     {   /* Check the EXIF header component */\r
214         static const unsigned char ExifHeader[] = "Exif\0\0";\r
215         if (memcmp(CharBuf+0, ExifHeader,6)){\r
216                         strcpy(m_szLastError,"Incorrect Exif header");\r
217                         return false;\r
218                 }\r
219     }\r
220 \r
221     if (memcmp(CharBuf+6,"II",2) == 0){\r
222         MotorolaOrder = 0;\r
223     }else{\r
224         if (memcmp(CharBuf+6,"MM",2) == 0){\r
225             MotorolaOrder = 1;\r
226         }else{\r
227             strcpy(m_szLastError,"Invalid Exif alignment marker.");\r
228                         return false;\r
229         }\r
230     }\r
231 \r
232     /* Check the next two values for correctness. */\r
233     if (Get16u(CharBuf+8) != 0x2a){\r
234         strcpy(m_szLastError,"Invalid Exif start (1)");\r
235                 return false;\r
236     }\r
237 \r
238         int FirstOffset = Get32u(CharBuf+10);\r
239     /* <Richard Collins> \r
240         if (FirstOffset < 8 || FirstOffset > 16){\r
241         // I used to ensure this was set to 8 (website I used indicated its 8)\r
242         // but PENTAX Optio 230 has it set differently, and uses it as offset. (Sept 11 2002)\r
243         strcpy(m_szLastError,"Suspicious offset of first IFD value");\r
244                 return false;\r
245     }*/\r
246 \r
247     unsigned char * LastExifRefd = CharBuf;\r
248 \r
249     /* First directory starts 16 bytes in.  Offsets start at 8 bytes in. */\r
250     if (!ProcessExifDir(CharBuf+14, CharBuf+6, length-6, m_exifinfo, &LastExifRefd))\r
251                 return false;\r
252 \r
253         /* <Richard Collins> give a chance for a second directory */\r
254         if (FirstOffset > 8) {\r
255                 if (!ProcessExifDir(CharBuf+14+FirstOffset-8, CharBuf+6, length-6, m_exifinfo, &LastExifRefd))\r
256                         return false;\r
257         }\r
258 \r
259     /* This is how far the interesting (non thumbnail) part of the exif went. */\r
260     // int ExifSettingsLength = LastExifRefd - CharBuf;\r
261 \r
262     /* Compute the CCD width, in milimeters. */\r
263     if (m_exifinfo->FocalplaneXRes != 0){\r
264         m_exifinfo->CCDWidth = (float)(ExifImageWidth * m_exifinfo->FocalplaneUnits / m_exifinfo->FocalplaneXRes);\r
265     }\r
266 \r
267         return true;\r
268 }\r
269 //--------------------------------------------------------------------------\r
270 // Get 16 bits motorola order (always) for jpeg header stuff.\r
271 //--------------------------------------------------------------------------\r
272 int CxImageJPG::CxExifInfo::Get16m(void * Short)\r
273 {\r
274     return (((unsigned char *)Short)[0] << 8) | ((unsigned char *)Short)[1];\r
275 }\r
276 ////////////////////////////////////////////////////////////////////////////////\r
277 /*--------------------------------------------------------------------------\r
278    Convert a 16 bit unsigned value from file's native byte order\r
279 --------------------------------------------------------------------------*/\r
280 int CxImageJPG::CxExifInfo::Get16u(void * Short)\r
281 {\r
282     if (MotorolaOrder){\r
283         return (((unsigned char *)Short)[0] << 8) | ((unsigned char *)Short)[1];\r
284     }else{\r
285         return (((unsigned char *)Short)[1] << 8) | ((unsigned char *)Short)[0];\r
286     }\r
287 }\r
288 ////////////////////////////////////////////////////////////////////////////////\r
289 /*--------------------------------------------------------------------------\r
290    Convert a 32 bit signed value from file's native byte order\r
291 --------------------------------------------------------------------------*/\r
292 long CxImageJPG::CxExifInfo::Get32s(void * Long)\r
293 {\r
294     if (MotorolaOrder){\r
295         return  ((( char *)Long)[0] << 24) | (((unsigned char *)Long)[1] << 16)\r
296               | (((unsigned char *)Long)[2] << 8 ) | (((unsigned char *)Long)[3] << 0 );\r
297     }else{\r
298         return  ((( char *)Long)[3] << 24) | (((unsigned char *)Long)[2] << 16)\r
299               | (((unsigned char *)Long)[1] << 8 ) | (((unsigned char *)Long)[0] << 0 );\r
300     }\r
301 }\r
302 ////////////////////////////////////////////////////////////////////////////////\r
303 /*--------------------------------------------------------------------------\r
304    Convert a 32 bit unsigned value from file's native byte order\r
305 --------------------------------------------------------------------------*/\r
306 unsigned long CxImageJPG::CxExifInfo::Get32u(void * Long)\r
307 {\r
308     return (unsigned long)Get32s(Long) & 0xffffffff;\r
309 }\r
310 ////////////////////////////////////////////////////////////////////////////////\r
311 \r
312 /* Describes format descriptor */\r
313 static const int BytesPerFormat[] = {0,1,1,2,4,8,1,1,2,4,8,4,8};\r
314 #define NUM_FORMATS 12\r
315 \r
316 #define FMT_BYTE       1 \r
317 #define FMT_STRING     2\r
318 #define FMT_USHORT     3\r
319 #define FMT_ULONG      4\r
320 #define FMT_URATIONAL  5\r
321 #define FMT_SBYTE      6\r
322 #define FMT_UNDEFINED  7\r
323 #define FMT_SSHORT     8\r
324 #define FMT_SLONG      9\r
325 #define FMT_SRATIONAL 10\r
326 #define FMT_SINGLE    11\r
327 #define FMT_DOUBLE    12\r
328 \r
329 /* Describes tag values */\r
330 \r
331 #define TAG_EXIF_VERSION      0x9000\r
332 #define TAG_EXIF_OFFSET       0x8769\r
333 #define TAG_INTEROP_OFFSET    0xa005\r
334 \r
335 #define TAG_MAKE              0x010F\r
336 #define TAG_MODEL             0x0110\r
337 \r
338 #define TAG_ORIENTATION       0x0112\r
339 #define TAG_XRESOLUTION       0x011A\r
340 #define TAG_YRESOLUTION       0x011B\r
341 #define TAG_RESOLUTIONUNIT    0x0128\r
342 \r
343 #define TAG_EXPOSURETIME      0x829A\r
344 #define TAG_FNUMBER           0x829D\r
345 \r
346 #define TAG_SHUTTERSPEED      0x9201\r
347 #define TAG_APERTURE          0x9202\r
348 #define TAG_BRIGHTNESS        0x9203\r
349 #define TAG_MAXAPERTURE       0x9205\r
350 #define TAG_FOCALLENGTH       0x920A\r
351 \r
352 #define TAG_DATETIME_ORIGINAL 0x9003\r
353 #define TAG_USERCOMMENT       0x9286\r
354 \r
355 #define TAG_SUBJECT_DISTANCE  0x9206\r
356 #define TAG_FLASH             0x9209\r
357 \r
358 #define TAG_FOCALPLANEXRES    0xa20E\r
359 #define TAG_FOCALPLANEYRES    0xa20F\r
360 #define TAG_FOCALPLANEUNITS   0xa210\r
361 #define TAG_EXIF_IMAGEWIDTH   0xA002\r
362 #define TAG_EXIF_IMAGELENGTH  0xA003\r
363 \r
364 /* the following is added 05-jan-2001 vcs */\r
365 #define TAG_EXPOSURE_BIAS     0x9204\r
366 #define TAG_WHITEBALANCE      0x9208\r
367 #define TAG_METERING_MODE     0x9207\r
368 #define TAG_EXPOSURE_PROGRAM  0x8822\r
369 #define TAG_ISO_EQUIVALENT    0x8827\r
370 #define TAG_COMPRESSION_LEVEL 0x9102\r
371 \r
372 #define TAG_THUMBNAIL_OFFSET  0x0201\r
373 #define TAG_THUMBNAIL_LENGTH  0x0202\r
374 \r
375 \r
376 /*--------------------------------------------------------------------------\r
377    Process one of the nested EXIF directories.\r
378 --------------------------------------------------------------------------*/\r
379 bool CxImageJPG::CxExifInfo::ProcessExifDir(unsigned char * DirStart, unsigned char * OffsetBase, unsigned ExifLength,\r
380                            EXIFINFO * const m_exifinfo, unsigned char ** const LastExifRefdP, int NestingLevel)\r
381 {\r
382     int de;\r
383     int a;\r
384     int NumDirEntries;\r
385     unsigned ThumbnailOffset = 0;\r
386     unsigned ThumbnailSize = 0;\r
387 \r
388     if (NestingLevel > 4){\r
389         strcpy(m_szLastError,"Maximum directory nesting exceeded (corrupt exif header)");\r
390         return false;\r
391     }\r
392 \r
393     NumDirEntries = Get16u(DirStart);\r
394 \r
395     if ((DirStart+2+NumDirEntries*12) > (OffsetBase+ExifLength)){\r
396         strcpy(m_szLastError,"Illegally sized directory");\r
397                 return false;\r
398     }\r
399 \r
400     for (de=0;de<NumDirEntries;de++){\r
401         int Tag, Format, Components;\r
402         unsigned char * ValuePtr;\r
403             /* This actually can point to a variety of things; it must be\r
404                cast to other types when used.  But we use it as a byte-by-byte\r
405                cursor, so we declare it as a pointer to a generic byte here.\r
406             */\r
407         int ByteCount;\r
408         unsigned char * DirEntry;\r
409         DirEntry = DirStart+2+12*de;\r
410 \r
411         Tag = Get16u(DirEntry);\r
412         Format = Get16u(DirEntry+2);\r
413         Components = Get32u(DirEntry+4);\r
414 \r
415         if ((Format-1) >= NUM_FORMATS) {\r
416             /* (-1) catches illegal zero case as unsigned underflows to positive large */\r
417             strcpy(m_szLastError,"Illegal format code in EXIF dir");\r
418                         return false;\r
419                 }\r
420 \r
421         ByteCount = Components * BytesPerFormat[Format];\r
422 \r
423         if (ByteCount > 4){\r
424             unsigned OffsetVal;\r
425             OffsetVal = Get32u(DirEntry+8);\r
426             /* If its bigger than 4 bytes, the dir entry contains an offset.*/\r
427             if (OffsetVal+ByteCount > ExifLength){\r
428                 /* Bogus pointer offset and / or bytecount value */\r
429                 strcpy(m_szLastError,"Illegal pointer offset value in EXIF.");\r
430                                 return false;\r
431             }\r
432             ValuePtr = OffsetBase+OffsetVal;\r
433         }else{\r
434             /* 4 bytes or less and value is in the dir entry itself */\r
435             ValuePtr = DirEntry+8;\r
436         }\r
437 \r
438         if (*LastExifRefdP < ValuePtr+ByteCount){\r
439             /* Keep track of last byte in the exif header that was\r
440                actually referenced.  That way, we know where the\r
441                discardable thumbnail data begins.\r
442             */\r
443             *LastExifRefdP = ValuePtr+ByteCount;\r
444         }\r
445 \r
446         /* Extract useful components of tag */\r
447         switch(Tag){\r
448 \r
449             case TAG_MAKE:\r
450                 strncpy(m_exifinfo->CameraMake, (char*)ValuePtr, 31);\r
451                 break;\r
452 \r
453             case TAG_MODEL:\r
454                 strncpy(m_exifinfo->CameraModel, (char*)ValuePtr, 39);\r
455                 break;\r
456 \r
457                         case TAG_EXIF_VERSION:\r
458                                 strncpy(m_exifinfo->Version,(char*)ValuePtr, 4);\r
459                                 break;\r
460 \r
461             case TAG_DATETIME_ORIGINAL:\r
462                 strncpy(m_exifinfo->DateTime, (char*)ValuePtr, 19);\r
463                 break;\r
464 \r
465             case TAG_USERCOMMENT:\r
466                 // Olympus has this padded with trailing spaces. Remove these first. \r
467                 for (a=ByteCount;;){\r
468                     a--;\r
469                     if (((char*)ValuePtr)[a] == ' '){\r
470                         ((char*)ValuePtr)[a] = '\0';\r
471                     }else{\r
472                         break;\r
473                     }\r
474                     if (a == 0) break;\r
475                 }\r
476 \r
477                 /* Copy the comment */\r
478                 if (memcmp(ValuePtr, "ASCII",5) == 0){\r
479                     for (a=5;a<10;a++){\r
480                         char c;\r
481                         c = ((char*)ValuePtr)[a];\r
482                         if (c != '\0' && c != ' '){\r
483                             strncpy(m_exifinfo->Comments, (char*)ValuePtr+a, 199);\r
484                             break;\r
485                         }\r
486                     }\r
487                     \r
488                 }else{\r
489                     strncpy(m_exifinfo->Comments, (char*)ValuePtr, 199);\r
490                 }\r
491                 break;\r
492 \r
493             case TAG_FNUMBER:\r
494                 /* Simplest way of expressing aperture, so I trust it the most.\r
495                    (overwrite previously computd value if there is one)\r
496                    */\r
497                 m_exifinfo->ApertureFNumber = (float)ConvertAnyFormat(ValuePtr, Format);\r
498                 break;\r
499 \r
500             case TAG_APERTURE:\r
501             case TAG_MAXAPERTURE:\r
502                 /* More relevant info always comes earlier, so only\r
503                  use this field if we don't have appropriate aperture\r
504                  information yet. \r
505                 */\r
506                 if (m_exifinfo->ApertureFNumber == 0){\r
507                     m_exifinfo->ApertureFNumber = (float)exp(ConvertAnyFormat(ValuePtr, Format)*log(2.0f)*0.5);\r
508                 }\r
509                 break;\r
510 \r
511                         case TAG_BRIGHTNESS:\r
512                                 m_exifinfo->Brightness = (float)ConvertAnyFormat(ValuePtr, Format);\r
513                                 break;\r
514 \r
515             case TAG_FOCALLENGTH:\r
516                 /* Nice digital cameras actually save the focal length\r
517                    as a function of how farthey are zoomed in. \r
518                 */\r
519 \r
520                 m_exifinfo->FocalLength = (float)ConvertAnyFormat(ValuePtr, Format);\r
521                 break;\r
522 \r
523             case TAG_SUBJECT_DISTANCE:\r
524                 /* Inidcates the distacne the autofocus camera is focused to.\r
525                    Tends to be less accurate as distance increases.\r
526                 */\r
527                 m_exifinfo->Distance = (float)ConvertAnyFormat(ValuePtr, Format);\r
528                 break;\r
529 \r
530             case TAG_EXPOSURETIME:\r
531                 /* Simplest way of expressing exposure time, so I\r
532                    trust it most.  (overwrite previously computd value\r
533                    if there is one) \r
534                 */\r
535                 m_exifinfo->ExposureTime = \r
536                     (float)ConvertAnyFormat(ValuePtr, Format);\r
537                 break;\r
538 \r
539             case TAG_SHUTTERSPEED:\r
540                 /* More complicated way of expressing exposure time,\r
541                    so only use this value if we don't already have it\r
542                    from somewhere else.  \r
543                 */\r
544                 if (m_exifinfo->ExposureTime == 0){\r
545                     m_exifinfo->ExposureTime = (float)\r
546                         (1/exp(ConvertAnyFormat(ValuePtr, Format)*log(2.0f)));\r
547                 }\r
548                 break;\r
549 \r
550             case TAG_FLASH:\r
551                 if ((int)ConvertAnyFormat(ValuePtr, Format) & 7){\r
552                     m_exifinfo->FlashUsed = 1;\r
553                 }else{\r
554                     m_exifinfo->FlashUsed = 0;\r
555                 }\r
556                 break;\r
557 \r
558             case TAG_ORIENTATION:\r
559                 m_exifinfo->Orientation = (int)ConvertAnyFormat(ValuePtr, Format);\r
560                 if (m_exifinfo->Orientation < 1 || m_exifinfo->Orientation > 8){\r
561                     strcpy(m_szLastError,"Undefined rotation value");\r
562                     m_exifinfo->Orientation = 0;\r
563                 }\r
564                 break;\r
565 \r
566             case TAG_EXIF_IMAGELENGTH:\r
567             case TAG_EXIF_IMAGEWIDTH:\r
568                 /* Use largest of height and width to deal with images\r
569                    that have been rotated to portrait format.  \r
570                 */\r
571                 a = (int)ConvertAnyFormat(ValuePtr, Format);\r
572                 if (ExifImageWidth < a) ExifImageWidth = a;\r
573                 break;\r
574 \r
575             case TAG_FOCALPLANEXRES:\r
576                 m_exifinfo->FocalplaneXRes = (float)ConvertAnyFormat(ValuePtr, Format);\r
577                 break;\r
578 \r
579             case TAG_FOCALPLANEYRES:\r
580                 m_exifinfo->FocalplaneYRes = (float)ConvertAnyFormat(ValuePtr, Format);\r
581                 break;\r
582 \r
583                         case TAG_RESOLUTIONUNIT:\r
584                 switch((int)ConvertAnyFormat(ValuePtr, Format)){\r
585                     case 1: m_exifinfo->ResolutionUnit = 1.0f; break; /* 1 inch */\r
586                     case 2:     m_exifinfo->ResolutionUnit = 1.0f; break;\r
587                     case 3: m_exifinfo->ResolutionUnit = 0.3937007874f;    break;  /* 1 centimeter*/\r
588                     case 4: m_exifinfo->ResolutionUnit = 0.03937007874f;   break;  /* 1 millimeter*/\r
589                     case 5: m_exifinfo->ResolutionUnit = 0.00003937007874f;  /* 1 micrometer*/\r
590                 }\r
591                 break;\r
592 \r
593             case TAG_FOCALPLANEUNITS:\r
594                 switch((int)ConvertAnyFormat(ValuePtr, Format)){\r
595                     case 1: m_exifinfo->FocalplaneUnits = 1.0f; break; /* 1 inch */\r
596                     case 2:     m_exifinfo->FocalplaneUnits = 1.0f; break;\r
597                     case 3: m_exifinfo->FocalplaneUnits = 0.3937007874f;    break;  /* 1 centimeter*/\r
598                     case 4: m_exifinfo->FocalplaneUnits = 0.03937007874f;   break;  /* 1 millimeter*/\r
599                     case 5: m_exifinfo->FocalplaneUnits = 0.00003937007874f;  /* 1 micrometer*/\r
600                 }\r
601                 break;\r
602 \r
603                 // Remaining cases contributed by: Volker C. Schoech <schoech(at)gmx(dot)de>\r
604 \r
605             case TAG_EXPOSURE_BIAS:\r
606                 m_exifinfo->ExposureBias = (float) ConvertAnyFormat(ValuePtr, Format);\r
607                 break;\r
608 \r
609             case TAG_WHITEBALANCE:\r
610                 m_exifinfo->Whitebalance = (int)ConvertAnyFormat(ValuePtr, Format);\r
611                 break;\r
612 \r
613             case TAG_METERING_MODE:\r
614                 m_exifinfo->MeteringMode = (int)ConvertAnyFormat(ValuePtr, Format);\r
615                 break;\r
616 \r
617             case TAG_EXPOSURE_PROGRAM:\r
618                 m_exifinfo->ExposureProgram = (int)ConvertAnyFormat(ValuePtr, Format);\r
619                 break;\r
620 \r
621             case TAG_ISO_EQUIVALENT:\r
622                 m_exifinfo->ISOequivalent = (int)ConvertAnyFormat(ValuePtr, Format);\r
623                 if ( m_exifinfo->ISOequivalent < 50 ) m_exifinfo->ISOequivalent *= 200;\r
624                 break;\r
625 \r
626             case TAG_COMPRESSION_LEVEL:\r
627                 m_exifinfo->CompressionLevel = (int)ConvertAnyFormat(ValuePtr, Format);\r
628                 break;\r
629 \r
630             case TAG_XRESOLUTION:\r
631                 m_exifinfo->Xresolution = (float)ConvertAnyFormat(ValuePtr, Format);\r
632                 break;\r
633             case TAG_YRESOLUTION:\r
634                 m_exifinfo->Yresolution = (float)ConvertAnyFormat(ValuePtr, Format);\r
635                 break;\r
636 \r
637             case TAG_THUMBNAIL_OFFSET:\r
638                 ThumbnailOffset = (unsigned)ConvertAnyFormat(ValuePtr, Format);\r
639                 break;\r
640 \r
641             case TAG_THUMBNAIL_LENGTH:\r
642                 ThumbnailSize = (unsigned)ConvertAnyFormat(ValuePtr, Format);\r
643                 break;\r
644 \r
645         }\r
646 \r
647         if (Tag == TAG_EXIF_OFFSET || Tag == TAG_INTEROP_OFFSET){\r
648             unsigned char * SubdirStart;\r
649                         unsigned Offset = Get32u(ValuePtr);\r
650                         if (Offset>8){\r
651                                 SubdirStart = OffsetBase + Offset;\r
652                                 if (SubdirStart < OffsetBase || \r
653                                         SubdirStart > OffsetBase+ExifLength){\r
654                                         strcpy(m_szLastError,"Illegal subdirectory link");\r
655                                         return false;\r
656                                 }\r
657                                 ProcessExifDir(SubdirStart, OffsetBase, ExifLength, m_exifinfo, LastExifRefdP, NestingLevel+1);\r
658                         }\r
659             continue;\r
660         }\r
661     }\r
662 \r
663 \r
664     {\r
665         /* In addition to linking to subdirectories via exif tags,\r
666            there's also a potential link to another directory at the end\r
667            of each directory.  This has got to be the result of a\r
668            committee!  \r
669         */\r
670         unsigned char * SubdirStart;\r
671         unsigned Offset;\r
672         Offset = Get16u(DirStart+2+12*NumDirEntries);\r
673         if (Offset){\r
674             SubdirStart = OffsetBase + Offset;\r
675             if (SubdirStart < OffsetBase \r
676                 || SubdirStart > OffsetBase+ExifLength){\r
677                 strcpy(m_szLastError,"Illegal subdirectory link");\r
678                                 return false;\r
679             }\r
680             ProcessExifDir(SubdirStart, OffsetBase, ExifLength, m_exifinfo, LastExifRefdP, NestingLevel+1);\r
681         }\r
682     }\r
683 \r
684 \r
685     if (ThumbnailSize && ThumbnailOffset){\r
686         if (ThumbnailSize + ThumbnailOffset <= ExifLength){\r
687             /* The thumbnail pointer appears to be valid.  Store it. */\r
688             m_exifinfo->ThumbnailPointer = OffsetBase + ThumbnailOffset;\r
689             m_exifinfo->ThumbnailSize = ThumbnailSize;\r
690         }\r
691     }\r
692 \r
693         return true;\r
694 }\r
695 ////////////////////////////////////////////////////////////////////////////////\r
696 /*--------------------------------------------------------------------------\r
697    Evaluate number, be it int, rational, or float from directory.\r
698 --------------------------------------------------------------------------*/\r
699 double CxImageJPG::CxExifInfo::ConvertAnyFormat(void * ValuePtr, int Format)\r
700 {\r
701     double Value;\r
702     Value = 0;\r
703 \r
704     switch(Format){\r
705         case FMT_SBYTE:     Value = *(signed char *)ValuePtr;  break;\r
706         case FMT_BYTE:      Value = *(unsigned char *)ValuePtr;        break;\r
707 \r
708         case FMT_USHORT:    Value = Get16u(ValuePtr);          break;\r
709         case FMT_ULONG:     Value = Get32u(ValuePtr);          break;\r
710 \r
711         case FMT_URATIONAL:\r
712         case FMT_SRATIONAL: \r
713             {\r
714                 int Num,Den;\r
715                 Num = Get32s(ValuePtr);\r
716                 Den = Get32s(4+(char *)ValuePtr);\r
717                 if (Den == 0){\r
718                     Value = 0;\r
719                 }else{\r
720                     Value = (double)Num/Den;\r
721                 }\r
722                 break;\r
723             }\r
724 \r
725         case FMT_SSHORT:    Value = (signed short)Get16u(ValuePtr);  break;\r
726         case FMT_SLONG:     Value = Get32s(ValuePtr);                break;\r
727 \r
728         /* Not sure if this is correct (never seen float used in Exif format)\r
729          */\r
730         case FMT_SINGLE:    Value = (double)*(float *)ValuePtr;      break;\r
731         case FMT_DOUBLE:    Value = *(double *)ValuePtr;             break;\r
732     }\r
733     return Value;\r
734 }\r
735 ////////////////////////////////////////////////////////////////////////////////\r
736 void CxImageJPG::CxExifInfo::process_COM (const BYTE * Data, int length)\r
737 {\r
738     int ch;\r
739     char Comment[MAX_COMMENT+1];\r
740     int nch;\r
741     int a;\r
742 \r
743     nch = 0;\r
744 \r
745     if (length > MAX_COMMENT) length = MAX_COMMENT; // Truncate if it won't fit in our structure.\r
746 \r
747     for (a=2;a<length;a++){\r
748         ch = Data[a];\r
749 \r
750         if (ch == '\r' && Data[a+1] == '\n') continue; // Remove cr followed by lf.\r
751 \r
752         if (isprint(ch) || ch == '\n' || ch == '\t'){\r
753             Comment[nch++] = (char)ch;\r
754         }else{\r
755             Comment[nch++] = '?';\r
756         }\r
757     }\r
758 \r
759     Comment[nch] = '\0'; // Null terminate\r
760 \r
761     //if (ShowTags) printf("COM marker comment: %s\n",Comment);\r
762 \r
763     strcpy(m_exifinfo->Comments,Comment);\r
764 }\r
765 ////////////////////////////////////////////////////////////////////////////////\r
766 void CxImageJPG::CxExifInfo::process_SOFn (const BYTE * Data, int marker)\r
767 {\r
768     int data_precision, num_components;\r
769 \r
770     data_precision = Data[2];\r
771     m_exifinfo->Height = Get16m((void*)(Data+3));\r
772     m_exifinfo->Width = Get16m((void*)(Data+5));\r
773     num_components = Data[7];\r
774 \r
775     if (num_components == 3){\r
776         m_exifinfo->IsColor = 1;\r
777     }else{\r
778         m_exifinfo->IsColor = 0;\r
779     }\r
780 \r
781     m_exifinfo->Process = marker;\r
782 \r
783     //if (ShowTags) printf("JPEG image is %uw * %uh, %d color components, %d bits per sample\n",\r
784     //               ImageInfo.Width, ImageInfo.Height, num_components, data_precision);\r
785 }\r
786 ////////////////////////////////////////////////////////////////////////////////\r
787 /**\r
788  * this will work only on a CxImageJPG object, if the image originally has valid EXIF data\r
789  \verbatim\r
790         CxImageJPG jpg;\r
791         CxIOFile in,out;\r
792         in.Open("D:\\exif_in.jpg","rb");\r
793         out.Open("D:\\exif_out.jpg","w+b");\r
794         jpg.Decode(&in);\r
795         if (jpg.IsValid()){\r
796                 jpg.RotateLeft();\r
797                 jpg.Encode(&out);\r
798         }\r
799  \endverbatim\r
800 */\r
801 bool CxImageJPG::CxExifInfo::EncodeExif(CxFile * hFile)\r
802 {\r
803     int a;\r
804 \r
805     if (FindSection(M_SOS)==NULL){\r
806                 strcpy(m_szLastError,"Can't write exif : didn't read all");\r
807                 return false;\r
808     }\r
809 \r
810     // Initial static jpeg marker.\r
811         hFile->PutC(0xff);\r
812         hFile->PutC(0xd8);\r
813     \r
814     if (Sections[0].Type != M_EXIF && Sections[0].Type != M_JFIF){\r
815         // The image must start with an exif or jfif marker.  If we threw those away, create one.\r
816         static BYTE JfifHead[18] = {\r
817             0xff, M_JFIF,\r
818             0x00, 0x10, 'J' , 'F' , 'I' , 'F' , 0x00, 0x01, \r
819             0x01, 0x01, 0x01, 0x2C, 0x01, 0x2C, 0x00, 0x00 \r
820         };\r
821         hFile->Write(JfifHead, 18, 1);\r
822     }\r
823 \r
824     // Write all the misc sections\r
825     for (a=0;a<SectionsRead-1;a++){\r
826         hFile->PutC(0xff);\r
827         hFile->PutC((unsigned char)(Sections[a].Type));\r
828         hFile->Write(Sections[a].Data, Sections[a].Size, 1);\r
829     }\r
830 \r
831     // Write the remaining image data.\r
832     hFile->Write(Sections[a].Data, Sections[a].Size, 1);\r
833 \r
834         return true;\r
835 }\r
836 ////////////////////////////////////////////////////////////////////////////////\r
837 void CxImageJPG::CxExifInfo::DiscardAllButExif()\r
838 {\r
839     Section_t ExifKeeper;\r
840     Section_t CommentKeeper;\r
841     int a;\r
842 \r
843     memset(&ExifKeeper, 0, sizeof(ExifKeeper));\r
844     memset(&CommentKeeper, 0, sizeof(ExifKeeper));\r
845 \r
846     for (a=0;a<SectionsRead;a++){\r
847         if (Sections[a].Type == M_EXIF && ExifKeeper.Type == 0){\r
848             ExifKeeper = Sections[a];\r
849         }else if (Sections[a].Type == M_COM && CommentKeeper.Type == 0){\r
850             CommentKeeper = Sections[a];\r
851         }else{\r
852             free(Sections[a].Data);\r
853                         Sections[a].Data = 0;\r
854         }\r
855     }\r
856     SectionsRead = 0;\r
857     if (ExifKeeper.Type){\r
858         Sections[SectionsRead++] = ExifKeeper;\r
859     }\r
860     if (CommentKeeper.Type){\r
861         Sections[SectionsRead++] = CommentKeeper;\r
862     }\r
863 }\r
864 ////////////////////////////////////////////////////////////////////////////////\r
865 void* CxImageJPG::CxExifInfo::FindSection(int SectionType)\r
866 {\r
867     int a;\r
868     for (a=0;a<SectionsRead-1;a++){\r
869         if (Sections[a].Type == SectionType){\r
870             return &Sections[a];\r
871         }\r
872     }\r
873     // Could not be found.\r
874     return NULL;\r
875 }\r
876 ////////////////////////////////////////////////////////////////////////////////\r
877 #endif  // CXIMAGEJPG_SUPPORT_EXIF\r
878 \r