lib/gdi/picexif.cpp

   1 #include "picexif.h"
   2
   3 #define M_SOF0  0xC0
   4 #define M_SOF1  0xC1
   5 #define M_SOF2  0xC2
   6 #define M_SOF3  0xC3
   7 #define M_SOF5  0xC5
   8 #define M_SOF6  0xC6
   9 #define M_SOF7  0xC7
  10 #define M_SOF9  0xC9
  11 #define M_SOF10 0xCA
  12 #define M_SOF11 0xCB
  13 #define M_SOF13 0xCD
  14 #define M_SOF14 0xCE
  15 #define M_SOF15 0xCF
  16 #define M_SOI   0xD8
  17 #define M_EOI   0xD9
  18 #define M_SOS   0xDA
  19 #define M_JFIF  0xE0
  20 #define M_EXIF  0xE1
  21 #define M_COM   0xFE
  22
  23 #define NUM_FORMATS   12
  24 #define FMT_BYTE       1
  25 #define FMT_STRING     2
  26 #define FMT_USHORT     3
  27 #define FMT_ULONG      4
  28 #define FMT_URATIONAL  5
  29 #define FMT_SBYTE      6
  30 #define FMT_UNDEFINED  7
  31 #define FMT_SSHORT     8
  32 #define FMT_SLONG      9
  33 #define FMT_SRATIONAL 10
  34 #define FMT_SINGLE    11
  35 #define FMT_DOUBLE    12
  36
  37 #define TAG_EXIF_VERSION      0x9000
  38 #define TAG_EXIF_OFFSET       0x8769
  39 #define TAG_INTEROP_OFFSET    0xa005
  40 #define TAG_MAKE              0x010F
  41 #define TAG_MODEL             0x0110
  42 #define TAG_ORIENTATION       0x0112
  43 #define TAG_XRESOLUTION       0x011A
  44 #define TAG_YRESOLUTION       0x011B
  45 #define TAG_RESOLUTIONUNIT    0x0128
  46 #define TAG_EXPOSURETIME      0x829A
  47 #define TAG_FNUMBER           0x829D
  48 #define TAG_SHUTTERSPEED      0x9201
  49 #define TAG_APERTURE          0x9202
  50 #define TAG_BRIGHTNESS        0x9203
  51 #define TAG_MAXAPERTURE       0x9205
  52 #define TAG_FOCALLENGTH       0x920A
  53 #define TAG_DATETIME_ORIGINAL 0x9003
  54 #define TAG_USERCOMMENT       0x9286
  55 #define TAG_SUBJECT_DISTANCE  0x9206
  56 #define TAG_FLASH             0x9209
  57 #define TAG_FOCALPLANEXRES    0xa20E
  58 #define TAG_FOCALPLANEYRES    0xa20F
  59 #define TAG_FOCALPLANEUNITS   0xa210
  60 #define TAG_EXIF_IMAGEWIDTH   0xA002
  61 #define TAG_EXIF_IMAGELENGTH  0xA003
  62 #define TAG_EXPOSURE_BIAS     0x9204
  63 #define TAG_WHITEBALANCE      0x9208
  64 #define TAG_METERING_MODE     0x9207
  65 #define TAG_EXPOSURE_PROGRAM  0x8822
  66 #define TAG_ISO_EQUIVALENT    0x8827
  67 #define TAG_COMPRESSION_LEVEL 0x9102
  68 #define TAG_THUMBNAIL_OFFSET  0x0201
  69 #define TAG_THUMBNAIL_LENGTH  0x0202
  70
  71
  72 Cexif::Cexif()
  73 {
  74 }
  75
  76 Cexif::~Cexif()
  77 {
  78         //ClearExif();
  79 }
  80
  81 void Cexif::ClearExif()
  82 {
  83         if(freeinfo)
  84         {
  85                 for(int i=0;i<MAX_SECTIONS;i++)
  86                         if(Sections[i].Data) free(Sections[i].Data);
  87                                 delete m_exifinfo;
  88                 freeinfo = false;
  89         }
  90 }
  91
  92 bool Cexif::DecodeExif(const char *filename)
  93 {
  94         FILE * hFile = fopen(filename, "r");
  95         if(!hFile) return false;
  96
  97
  98         m_exifinfo = new EXIFINFO;
  99         memset(m_exifinfo,0,sizeof(EXIFINFO));
 100         freeinfo = true;
 101
 102         m_szLastError[0]='\0';
 103         ExifImageWidth = MotorolaOrder = SectionsRead=0;
 104         memset(&Sections, 0, MAX_SECTIONS * sizeof(Section_t));
 105
 106         int HaveCom = 0;
 107         int a = fgetc(hFile);
 108         strcpy(m_szLastError,"EXIF-Data not found");
 109
 110         if (a != 0xff || fgetc(hFile) != M_SOI) return false;
 111
 112         for(;;)
 113         {
 114                 int marker = 0;
 115                 int ll,lh, got, itemlen;
 116                 unsigned char * Data;
 117
 118                 if (SectionsRead >= MAX_SECTIONS)
 119                 {
 120                         strcpy(m_szLastError,"Too many sections in jpg file"); return false;
 121                 }
 122
 123                 for (a=0;a<7;a++)
 124                 {
 125                         marker = fgetc(hFile);
 126                         if (marker != 0xff) break;
 127
 128                         if (a >= 6)
 129                         {
 130                                 strcpy(m_szLastError,"too many padding unsigned chars\n"); return false;
 131                         }
 132                 }
 133
 134                 if (marker == 0xff)
 135                 {
 136                         strcpy(m_szLastError,"too many padding unsigned chars!"); return false;
 137                 }
 138
 139                 Sections[SectionsRead].Type = marker;
 140
 141                 lh = fgetc(hFile);
 142                 ll = fgetc(hFile);
 143
 144                 itemlen = (lh << 8) | ll;
 145
 146                 if (itemlen < 2)
 147                 {
 148                         strcpy(m_szLastError,"invalid marker"); return false;
 149                 }
 150                 Sections[SectionsRead].Size = itemlen;
 151
 152                 Data = (unsigned char *)malloc(itemlen);
 153                 if (Data == NULL)
 154                 {
 155                         strcpy(m_szLastError,"Could not allocate memory"); return false;
 156                 }
 157                 Sections[SectionsRead].Data = Data;
 158
 159
 160                 Data[0] = (unsigned char)lh;
 161                 Data[1] = (unsigned char)ll;
 162
 163                 got = fread(Data+2, 1, itemlen-2,hFile);
 164                 if (got != itemlen-2)
 165                 {
 166                         strcpy(m_szLastError,"Premature end of file?"); return false;
 167                 }
 168                 SectionsRead += 1;
 169
 170                 switch(marker)
 171                 {
 172                 case M_SOS:
 173                         return true;
 174                 case M_EOI:
 175                         printf("No image in jpeg!\n");
 176                         return false;
 177                 case M_COM:
 178                         if (HaveCom)
 179                         {
 180                                 free(Sections[--SectionsRead].Data);
 181                                 Sections[SectionsRead].Data=0;
 182                         }
 183                         else
 184                         {
 185                                 process_COM(Data, itemlen);
 186                                 HaveCom = 1;
 187                         }
 188                         break;
 189                 case M_JFIF:
 190                         free(Sections[--SectionsRead].Data);
 191                         Sections[SectionsRead].Data=0;
 192                         break;
 193                 case M_EXIF:
 194                         if (memcmp(Data+2, "Exif", 4) == 0)
 195                         {
 196                                 m_exifinfo->IsExif = process_EXIF((unsigned char *)Data+2, itemlen);
 197                         }
 198                         else
 199                         {
 200                                 free(Sections[--SectionsRead].Data);
 201                                 Sections[SectionsRead].Data=0;
 202                         }
 203                         break;
 204                 case M_SOF0:
 205                 case M_SOF1:
 206                 case M_SOF2:
 207                 case M_SOF3:
 208                 case M_SOF5:
 209                 case M_SOF6:
 210                 case M_SOF7:
 211                 case M_SOF9:
 212                 case M_SOF10:
 213                 case M_SOF11:
 214                 case M_SOF13:
 215                 case M_SOF14:
 216                 case M_SOF15:
 217                         process_SOFn(Data, marker);
 218                         break;
 219                 default:
 220                         break;
 221                 }
 222         }
 223
 224         fclose(hFile);
 225         return true;
 226 }
 227
 228 bool Cexif::process_EXIF(unsigned char * CharBuf, unsigned int length)
 229 {
 230         m_exifinfo->Comments[0] = '\0';
 231         ExifImageWidth = 0;
 232
 233         static const unsigned char ExifHeader[] = "Exif\0\0";
 234         if(memcmp(CharBuf+0, ExifHeader,6))
 235         {
 236                 strcpy(m_szLastError,"Incorrect Exif header"); return false;
 237         }
 238
 239         if (memcmp(CharBuf+6,"II",2) == 0) MotorolaOrder = 0;
 240         else
 241         {
 242                 if (memcmp(CharBuf+6,"MM",2) == 0) MotorolaOrder = 1;
 243                 else
 244                 {
 245                         strcpy(m_szLastError,"Invalid Exif alignment marker."); return false;
 246                 }
 247         }
 248
 249         if (Get16u(CharBuf+8) != 0x2a)
 250         {
 251                 strcpy(m_szLastError,"Invalid Exif start (1)"); return false;
 252         }
 253         int FirstOffset = Get32u(CharBuf+10);
 254         if (FirstOffset < 8 || FirstOffset > 16)
 255         {
 256                 strcpy(m_szLastError,"Suspicious offset of first IFD value"); return 0;
 257         }
 258         unsigned char * LastExifRefd = CharBuf;
 259
 260         if (!ProcessExifDir(CharBuf+14, CharBuf+6, length-6, m_exifinfo, &LastExifRefd)) return false;
 261
 262         if (m_exifinfo->FocalplaneXRes != 0)
 263                 m_exifinfo->CCDWidth = (float)(ExifImageWidth * m_exifinfo->FocalplaneUnits / m_exifinfo->FocalplaneXRes);
 264
 265         return true;
 266 }
 267
 268 int Cexif::Get16m(void * Short)
 269 {
 270         return (((unsigned char *)Short)[0] << 8) | ((unsigned char *)Short)[1];
 271 }
 272
 273 int Cexif::Get16u(void * Short)
 274 {
 275         if (MotorolaOrder)
 276         {
 277                 return (((unsigned char *)Short)[0] << 8) | ((unsigned char *)Short)[1];
 278         }
 279         else
 280         {
 281                 return (((unsigned char *)Short)[1] << 8) | ((unsigned char *)Short)[0];
 282         }
 283 }
 284
 285 long Cexif::Get32s(void * Long)
 286 {
 287         if (MotorolaOrder)
 288         {
 289                 return  ((( char *)Long)[0] << 24) | (((unsigned char *)Long)[1] << 16) | (((unsigned char *)Long)[2] << 8 ) | (((unsigned char *)Long)[3] << 0 );
 290         }
 291         else
 292         {
 293                 return  ((( char *)Long)[3] << 24) | (((unsigned char *)Long)[2] << 16) | (((unsigned char *)Long)[1] << 8 ) | (((unsigned char *)Long)[0] << 0 );
 294         }
 295 }
 296
 297 unsigned long Cexif::Get32u(void * Long)
 298 {
 299         return (unsigned long)Get32s(Long) & 0xffffffff;
 300 }
 301
 302 bool Cexif::ProcessExifDir(unsigned char * DirStart, unsigned char * OffsetBase, unsigned ExifLength, EXIFINFO * const m_exifinfo, unsigned char ** const LastExifRefdP )
 303 {
 304         int de, a, NumDirEntries;
 305         unsigned ThumbnailOffset = 0;
 306         unsigned ThumbnailSize = 0;
 307
 308         NumDirEntries = Get16u(DirStart);
 309
 310         if ((DirStart+2+NumDirEntries*12) > (OffsetBase+ExifLength))
 311         {
 312                 strcpy(m_szLastError,"Illegally sized directory"); return 0;
 313         }
 314
 315         for (de=0;de<NumDirEntries;de++)
 316         {
 317                 int Tag, Format, Components;
 318                 unsigned char * ValuePtr;
 319                 int BytesCount;
 320                 unsigned char * DirEntry;
 321                 DirEntry = DirStart+2+12*de;
 322                 Tag = Get16u(DirEntry);
 323                 Format = Get16u(DirEntry+2);
 324                 Components = Get32u(DirEntry+4);
 325
 326                 if ((Format-1) >= NUM_FORMATS)
 327                 {
 328                         strcpy(m_szLastError,"Illegal format code in EXIF dir"); return 0;
 329                 }
 330
 331                 BytesCount = Components * BytesPerFormat[Format];
 332
 333                 if (BytesCount > 4)
 334                 {
 335                         unsigned OffsetVal;
 336                         OffsetVal = Get32u(DirEntry+8);
 337                         if (OffsetVal+BytesCount > ExifLength)
 338                         {
 339                                 strcpy(m_szLastError,"Illegal pointer offset value in EXIF."); return 0;
 340                         }
 341                         ValuePtr = OffsetBase+OffsetVal;
 342                 }
 343                 else ValuePtr = DirEntry+8;
 344
 345                 if (*LastExifRefdP < ValuePtr+BytesCount) *LastExifRefdP = ValuePtr+BytesCount;
 346
 347                 switch(Tag)
 348                 {
 349                 case TAG_MAKE:
 350                         strncpy(m_exifinfo->CameraMake, (char*)ValuePtr, 31);
 351                         break;
 352                 case TAG_MODEL:
 353                         strncpy(m_exifinfo->CameraModel, (char*)ValuePtr, 39);
 354                         break;
 355                 case TAG_EXIF_VERSION:
 356                         strncpy(m_exifinfo->Version,(char*)ValuePtr, 4);
 357                         break;
 358                 case TAG_DATETIME_ORIGINAL:
 359                         strncpy(m_exifinfo->DateTime, (char*)ValuePtr, 19);
 360                         break;
 361                 case TAG_USERCOMMENT:
 362                         for (a=BytesCount;;)
 363                         {
 364                                 a--;
 365                                 if (((char*)ValuePtr)[a] == ' ') ((char*)ValuePtr)[a] = '\0';
 366                                 else break;
 367
 368                                 if (a == 0) break;
 369                         }
 370
 371                         if (memcmp(ValuePtr, "ASCII",5) == 0)
 372                         {
 373                                 for (a=5;a<10;a++)
 374                                 {
 375                                         char c;
 376                                         c = ((char*)ValuePtr)[a];
 377                                         if (c != '\0' && c != ' ')
 378                                         {
 379                                                 strncpy(m_exifinfo->Comments, (char*)ValuePtr+a, 199);
 380                                                 break;
 381                                         }
 382                                 }
 383
 384                         }
 385                         else strncpy(m_exifinfo->Comments, (char*)ValuePtr, 199);
 386                         break;
 387                 case TAG_FNUMBER:
 388                         m_exifinfo->ApertureFNumber = (float)ConvertAnyFormat(ValuePtr, Format);
 389                         break;
 390                 case TAG_APERTURE:
 391                 case TAG_MAXAPERTURE:
 392                         if (m_exifinfo->ApertureFNumber == 0)
 393                         {
 394                                 //m_exifinfo->ApertureFNumber = (float)exp(ConvertAnyFormat(ValuePtr, Format)*log(2)*0.5);
 395                         }
 396                         break;
 397                 case TAG_BRIGHTNESS:
 398                         m_exifinfo->Brightness = (float)ConvertAnyFormat(ValuePtr, Format);
 399                         break;
 400                 case TAG_FOCALLENGTH:
 401                         m_exifinfo->FocalLength = (float)ConvertAnyFormat(ValuePtr, Format);
 402                         break;
 403                 case TAG_SUBJECT_DISTANCE:
 404                         m_exifinfo->Distance = (float)ConvertAnyFormat(ValuePtr, Format);
 405                         break;
 406                 case TAG_EXPOSURETIME:
 407                         m_exifinfo->ExposureTime = (float)ConvertAnyFormat(ValuePtr, Format);
 408                         break;
 409                 case TAG_SHUTTERSPEED:
 410                         if (m_exifinfo->ExposureTime == 0)
 411                         {
 412                                 //m_exifinfo->ExposureTime = (float) (1/exp(ConvertAnyFormat(ValuePtr, Format)*log(2)));
 413                         }
 414                         break;
 415                 case TAG_FLASH:
 416                         if ((int)ConvertAnyFormat(ValuePtr, Format) & 7) strcpy(m_exifinfo->FlashUsed,"fire");
 417                         else strcpy(m_exifinfo->FlashUsed,"not fired");
 418                         break;
 419                 case TAG_ORIENTATION:
 420                         m_exifinfo->Orient = (int)ConvertAnyFormat(ValuePtr, Format);
 421                         switch((int)ConvertAnyFormat(ValuePtr, Format))
 422                         {
 423                         case 1:         strcpy(m_exifinfo->Orientation,"Top-Left"); break;
 424                         case 2:         strcpy(m_exifinfo->Orientation,"Top-Right"); break;
 425                         case 3:         strcpy(m_exifinfo->Orientation,"Bottom-Right"); break;
 426                         case 4:         strcpy(m_exifinfo->Orientation,"Bottom-Left"); break;
 427                         case 5:         strcpy(m_exifinfo->Orientation,"Left-Top"); break;
 428                         case 6:         strcpy(m_exifinfo->Orientation,"Right-Top"); break;
 429                         case 7:         strcpy(m_exifinfo->Orientation,"Right-Bottom"); break;
 430                         case 8:         strcpy(m_exifinfo->Orientation,"Left-Bottom"); break;
 431                         default:        strcpy(m_exifinfo->Orientation,"Undefined rotation value");
 432                         }
 433                         break;
 434                 case TAG_EXIF_IMAGELENGTH:
 435                 case TAG_EXIF_IMAGEWIDTH:
 436                         a = (int)ConvertAnyFormat(ValuePtr, Format);
 437                         if (ExifImageWidth < a) ExifImageWidth = a;
 438                         break;
 439                 case TAG_FOCALPLANEXRES:
 440                         m_exifinfo->FocalplaneXRes = (float)ConvertAnyFormat(ValuePtr, Format);
 441                         break;
 442                 case TAG_FOCALPLANEYRES:
 443                         m_exifinfo->FocalplaneYRes = (float)ConvertAnyFormat(ValuePtr, Format);
 444                         break;
 445                 case TAG_RESOLUTIONUNIT:
 446                         switch((int)ConvertAnyFormat(ValuePtr, Format))
 447                         {
 448                                 case 2: strcpy(m_exifinfo->ResolutionUnit,"inches"); break;
 449                                 case 3: strcpy(m_exifinfo->ResolutionUnit,"centimeters"); break;
 450                                 default: strcpy(m_exifinfo->ResolutionUnit,"reserved");
 451                         }
 452                         break;
 453                 case TAG_FOCALPLANEUNITS:
 454                         switch((int)ConvertAnyFormat(ValuePtr, Format))
 455                         {
 456                                 case 1: m_exifinfo->FocalplaneUnits = 1.0f; break;
 457                                 case 2: m_exifinfo->FocalplaneUnits = 1.0f; break;
 458                                 case 3: m_exifinfo->FocalplaneUnits = 0.3937007874f; break;
 459                                 case 4: m_exifinfo->FocalplaneUnits = 0.03937007874f; break;
 460                                 case 5: m_exifinfo->FocalplaneUnits = 0.00003937007874f;
 461                         }
 462                         break;
 463                 case TAG_EXPOSURE_BIAS:
 464                         m_exifinfo->ExposureBias = (float) ConvertAnyFormat(ValuePtr, Format);
 465                         break;
 466                 case TAG_WHITEBALANCE:
 467                         switch((int)ConvertAnyFormat(ValuePtr, Format))
 468                         {
 469                                 case 0: strcpy(m_exifinfo->LightSource,"unknown"); break;
 470                                 case 1: strcpy(m_exifinfo->LightSource,"Daylight"); break;
 471                                 case 2: strcpy(m_exifinfo->LightSource,"Fluorescent"); break;
 472                                 case 3: strcpy(m_exifinfo->LightSource,"Tungsten"); break;
 473                                 case 17: strcpy(m_exifinfo->LightSource,"Standard light A"); break;
 474                                 case 18: strcpy(m_exifinfo->LightSource,"Standard light B"); break;
 475                                 case 19: strcpy(m_exifinfo->LightSource,"Standard light C"); break;
 476                                 case 20: strcpy(m_exifinfo->LightSource,"D55"); break;
 477                                 case 21: strcpy(m_exifinfo->LightSource,"D65"); break;
 478                                 case 22: strcpy(m_exifinfo->LightSource,"D75"); break;
 479                                 default: strcpy(m_exifinfo->LightSource,"other"); break;
 480                         }
 481                         break;
 482                 case TAG_METERING_MODE:
 483                         switch((int)ConvertAnyFormat(ValuePtr, Format))
 484                         {
 485                                 case 0: strcpy(m_exifinfo->MeteringMode,"unknown"); break;
 486                                 case 1: strcpy(m_exifinfo->MeteringMode,"Average"); break;
 487                                 case 2: strcpy(m_exifinfo->MeteringMode,"Center-Weighted-Average"); break;
 488                                 case 3: strcpy(m_exifinfo->MeteringMode,"Spot"); break;
 489                                 case 4: strcpy(m_exifinfo->MeteringMode,"MultiSpot"); break;
 490                                 case 5: strcpy(m_exifinfo->MeteringMode,"Pattern"); break;
 491                                 case 6: strcpy(m_exifinfo->MeteringMode,"Partial"); break;
 492                                 default: strcpy(m_exifinfo->MeteringMode,"other"); break;
 493                         }
 494                         break;
 495                 case TAG_EXPOSURE_PROGRAM:
 496                         switch((int)ConvertAnyFormat(ValuePtr, Format))
 497                         {
 498                                 case 0: strcpy(m_exifinfo->ExposureProgram,"not defined"); break;
 499                                 case 1: strcpy(m_exifinfo->ExposureProgram,"Manual"); break;
 500                                 case 2: strcpy(m_exifinfo->ExposureProgram,"Normal program"); break;
 501                                 case 3: strcpy(m_exifinfo->ExposureProgram,"Aperture priority"); break;
 502                                 case 4: strcpy(m_exifinfo->ExposureProgram,"Shutter priority"); break;
 503                                 case 5: strcpy(m_exifinfo->ExposureProgram,"Creative program"); break;
 504                                 case 6: strcpy(m_exifinfo->ExposureProgram,"Action program"); break;
 505                                 case 7: strcpy(m_exifinfo->ExposureProgram,"Portrait mode"); break;
 506                                 case 8: strcpy(m_exifinfo->ExposureProgram,"Landscape mode"); break;
 507                                 default: strcpy(m_exifinfo->ExposureProgram,"reserved"); break;
 508                         }
 509                         break;
 510                 case TAG_ISO_EQUIVALENT:
 511                         m_exifinfo->ISOequivalent = (int)ConvertAnyFormat(ValuePtr, Format);
 512                         if ( m_exifinfo->ISOequivalent < 50 ) m_exifinfo->ISOequivalent *= 200;
 513                         break;
 514                 case TAG_COMPRESSION_LEVEL:
 515                         m_exifinfo->CompressionLevel = (int)ConvertAnyFormat(ValuePtr, Format);
 516                         break;
 517                 case TAG_XRESOLUTION:
 518                         m_exifinfo->Xresolution = (float)ConvertAnyFormat(ValuePtr, Format);
 519                         break;
 520                 case TAG_YRESOLUTION:
 521                         m_exifinfo->Yresolution = (float)ConvertAnyFormat(ValuePtr, Format);
 522                         break;
 523                 case TAG_THUMBNAIL_OFFSET:
 524                         ThumbnailOffset = (unsigned)ConvertAnyFormat(ValuePtr, Format);
 525                         break;
 526                 case TAG_THUMBNAIL_LENGTH:
 527                         ThumbnailSize = (unsigned)ConvertAnyFormat(ValuePtr, Format);
 528                         break;
 529                 }
 530
 531                 if (Tag == TAG_EXIF_OFFSET || Tag == TAG_INTEROP_OFFSET)
 532                 {
 533                         unsigned char * SubdirStart;
 534                         SubdirStart = OffsetBase + Get32u(ValuePtr);
 535                         if (SubdirStart < OffsetBase || SubdirStart > OffsetBase+ExifLength)
 536                         {
 537                                 strcpy(m_szLastError,"Illegal subdirectory link"); return 0;
 538                         }
 539                         ProcessExifDir(SubdirStart, OffsetBase, ExifLength, m_exifinfo, LastExifRefdP);
 540                         continue;
 541                 }
 542         }
 543
 544
 545         unsigned char * SubdirStart;
 546         unsigned Offset;
 547         Offset = Get16u(DirStart+2+12*NumDirEntries);
 548         if (Offset)
 549         {
 550                 SubdirStart = OffsetBase + Offset;
 551                 if (SubdirStart < OffsetBase || SubdirStart > OffsetBase+ExifLength)
 552                 {
 553                         strcpy(m_szLastError,"Illegal subdirectory link"); return 0;
 554                 }
 555                 ProcessExifDir(SubdirStart, OffsetBase, ExifLength, m_exifinfo, LastExifRefdP);
 556         }
 557
 558         if (ThumbnailSize && ThumbnailOffset)
 559         {
 560                 if (ThumbnailSize + ThumbnailOffset <= ExifLength)
 561                 {
 562                         m_exifinfo->ThumbnailPointer = OffsetBase + ThumbnailOffset;
 563                         m_exifinfo->ThumbnailSize = ThumbnailSize;
 564                 }
 565         }
 566
 567         return 1;
 568 }
 569
 570 double Cexif::ConvertAnyFormat(void * ValuePtr, int Format)
 571 {
 572         double Value = 0;
 573
 574         switch(Format)
 575         {
 576                 case FMT_SBYTE:         Value = *(signed char *)ValuePtr;       break;
 577                 case FMT_BYTE:          Value = *(unsigned char *)ValuePtr;     break;
 578                 case FMT_USHORT:        Value = Get16u(ValuePtr);               break;
 579                 case FMT_ULONG:         Value = Get32u(ValuePtr);               break;
 580                 case FMT_URATIONAL:
 581                 case FMT_SRATIONAL:
 582                 {
 583                         int Num = Get32s(ValuePtr);
 584                         int Den = Get32s(4+(char *)ValuePtr);
 585                         if (Den == 0) Value = 0;
 586                         else Value = (double)Num/Den;
 587                         break;
 588                 }
 589                 case FMT_SSHORT:        Value = (signed short)Get16u(ValuePtr); break;
 590                 case FMT_SLONG:         Value = Get32s(ValuePtr);               break;
 591                 case FMT_SINGLE:        Value = (double)*(float *)ValuePtr;     break;
 592                 case FMT_DOUBLE:        Value = *(double *)ValuePtr;            break;
 593         }
 594         return Value;
 595 }
 596
 597 void Cexif::process_COM (const unsigned char * Data, int length)
 598 {
 599         int ch,a;
 600         char Comment[MAX_COMMENT+1];
 601         int nch=0;
 602
 603         if (length > MAX_COMMENT) length = MAX_COMMENT;
 604
 605         for (a=2;a<length;a++)
 606         {
 607                 ch = Data[a];
 608                 if (ch == '\r' && Data[a+1] == '\n') continue;
 609                 if ((ch>=0x20) || ch == '\n' || ch == '\t') Comment[nch++] = (char)ch;
 610                 else Comment[nch++] = '?';
 611         }
 612         Comment[nch] = '\0';
 613         strcpy(m_exifinfo->Comments,Comment);
 614 }
 615
 616 void Cexif::process_SOFn (const unsigned char * Data, int marker)
 617 {
 618         int data_precision, num_components;
 619
 620         data_precision = Data[2];
 621         m_exifinfo->Height = Get16m((void*)(Data+3));
 622         m_exifinfo->Width = Get16m((void*)(Data+5));
 623         num_components = Data[7];
 624
 625         if (num_components == 3) strcpy(m_exifinfo->IsColor,"yes");
 626         else strcpy(m_exifinfo->IsColor,"no");
 627
 628         m_exifinfo->Process = marker;
 629 }
 630