程序博客网 > 情头软件即刻

读取JPG图片的Exif属性(二) - C代码实现

来源：互联网 发布：情头软件即刻 编辑：程序博客网 时间：2024/05/29 12:06

读区Exif属性简介

        读取Exif基本上就是在懂得Exif的格式的基础上，详细见上文： 

读取JPG图片的Exif属性 - Exif信息简介

，然后就是对图片的数据进行字节分析了。这个分析也是非常重要的，就是一个一个字节来分析图片的Exif属性，一般这段字节就是图片的开始部分。可以使用 工具将JPG图片按照16进制的格式打开，然后在对着图片来分析。

        由于国内关于此部分的讲述非常少，我在国外的一个网站上找到一个简单的读取Exif属性的实例，下面就是关于这个demo自己做的一些修改和理解。

如下是一个实际图片的16进制数据：
FF D8 FF E0 00 10 4A 46 49 46 00 01 02 01 00 60
00 60   00 00 FF E1 08 32 45 78 69 66 00 00 49 49

 DecodeExif函数主要是获取到Eixf属性在图片数据中入口地址：

第一次执行DecodeExif 中的for(;;)读取的是section FF E0M_JFIF
 FF D8       SOI
 FF E0       APP0
 00 10      APP0 LENGTH = 16

FF D8 FF E0 00 10 4A 46 49 46 00 01 02 01 00 60
00 60   00 00 FF E1 08 32 45 78 69 66 00 00 49 49
蓝色部分就是读取的长度16个字节。

第二次次执行DecodeExif 中的for(;;)读取的是section FF E0M_JFIF

FF D8 FF E0 00 10 4A 46 49 46 00 01 02 01 00 60
00 60   00 00 FF E1 08 32 45 78 69 66 00 00 49 49

FF E1      APP1
 08 32     APP0 LENGTH = 08 32 = 2098
45 78 69 66   "Exif" 字符 
也就是代码：if(memcmp(Data+2,"Exif",4)==0)所定义那样，获取四个字符，
从FF E1开始 长度为2098 个字节。
m_exifinfo->IsExif= process_EXIF((unsignedchar*)Data+2, itemlen);
从这个函数开始，分析Exif各种属性，也就是获取到Eixf属性在图片数据中入口地址以及Exif所占的长度
  1. bool Cexif::DecodeExif(FILE * hFile)
  2. {
  3.     int a;
  4.     int HaveCom = 0;
  6.     a = fgetc(hFile);
  8.     if (a != 0xff || fgetc(hFile) != M_SOI){
  9.         return 0;
  10.     }
  12.     for(;;){
  13.         int itemlen;
  14.         int marker = 0;
  15.         int ll,lh, got;
  16.         unsigned char * Data;
  18.         if (SectionsRead >= MAX_SECTIONS){
  19. strcpy(m_szLastError,"Too many sections in jpg file");
  20. return 0;
  21.         }
  23.         for (a=0;a<7;a++){
  24.             marker = fgetc(hFile);
  25.             if (marker != 0xff) break;
  27.             if (a >= 6){
  28.                 printf("too many padding unsigned chars\n");
  29.                 return 0;
  30.             }
  31.         }
  33.         if (marker == 0xff){
  34.             // 0xff is legal padding, but if we get that many, something's wrong.
  35.             strcpy(m_szLastError,"too many padding unsigned chars!");
  36. return 0;
  37.         }
  39.         Sections[SectionsRead].Type = marker;
  41.         // Read the length of the section.
  42.         lh = fgetc(hFile);
  43.         ll = fgetc(hFile);
  45.         itemlen = (lh << 8) | ll;
  47.         if (itemlen < 2){
  48.             strcpy(m_szLastError,"invalid marker");
  49. return 0;
  50.         }
  52.         Sections[SectionsRead].Size = itemlen;
  54.         Data = (unsigned char *)malloc(itemlen);
  55.         if (Data == NULL){
  56.             strcpy(m_szLastError,"Could not allocate memory");
  57. return 0;
  58.         }
  59.         Sections[SectionsRead].Data = Data;
  61.         // Store first two pre-read unsigned chars.
  62.         Data[0] = (unsigned char)lh;
  63.         Data[1] = (unsigned char)ll;
  65.         got = fread(Data+2, 1, itemlen-2,hFile); // Read the whole section.
  66.         if (got != itemlen-2){
  67.             strcpy(m_szLastError,"Premature end of file?");
  68. return 0;
  69.         }
  70.         SectionsRead += 1;
  72.         switch(marker){
  74.             case M_SOS:   // stop before hitting compressed data 
  75.                 // If reading entire image is requested, read the rest of the data.
  76.                 /*if (ReadMode & READ_IMAGE){
  77.                     int cp, ep, size;
  78.                     // Determine how much file is left.
  79.                     cp = ftell(infile);
  80.                     fseek(infile, 0, SEEK_END);
  81.                     ep = ftell(infile);
  82.                     fseek(infile, cp, SEEK_SET);
  84.                     size = ep-cp;
  85.                     Data = (uchar *)malloc(size);
  86.                     if (Data == NULL){
  87.                         strcpy(m_szLastError,"could not allocate data for entire image");
  88. return 0;
  89.                     }
  91.                     got = fread(Data, 1, size, infile);
  92.                     if (got != size){
  93.                         strcpy(m_szLastError,"could not read the rest of the image");
  94. return 0;
  95.                     }
  97.                     Sections[SectionsRead].Data = Data;
  98.                     Sections[SectionsRead].Size = size;
  99.                     Sections[SectionsRead].Type = PSEUDO_IMAGE_MARKER;
  100.                     SectionsRead ++;
  101.                     HaveAll = 1;
  102.                 }*/
  103.                 return 1;
  105.             case M_EOI:   // in case it's a tables-only JPEG stream
  106.                 printf("No image in jpeg!\n");
  107.                 return 0;
  109.             case M_COM: // Comment section
  110.                 if (HaveCom){
  111.                     // Discard this section.
  112.                     free(Sections[--SectionsRead].Data);
  113. Sections[SectionsRead].Data=0;
  114.                 }else{
  115.                     process_COM(Data, itemlen);
  116.                     HaveCom = 1;
  117.                 }
  118.                 break;
  120.             case M_JFIF:
  121.                 // Regular jpegs always have this tag, exif images have the exif
  122.                 // marker instead, althogh ACDsee will write images with both markers.
  123.                 // this program will re-create this marker on absence of exif marker.
  124.                 // hence no need to keep the copy from the file.
  125.                 free(Sections[--SectionsRead].Data);
  126. Sections[SectionsRead].Data=0;
  127.                 break;
  129.             case M_EXIF:
  130.                 // Seen files from some 'U-lead' software with Vivitar scanner
  131.                 // that uses marker 31 for non exif stuff.  Thus make sure 
  132.                 // it says 'Exif' in the section before treating it as exif.
  133.                 if (memcmp(Data+2, "Exif", 4) == 0){
  134.                     m_exifinfo->IsExif = process_EXIF((unsigned char *)Data+2, itemlen);
  135.                 }else{
  136.                     // Discard this section.
  137.                     free(Sections[--SectionsRead].Data);
  138. Sections[SectionsRead].Data=0;
  139.                 }
  140.                 break;
  142.             case M_SOF0: 
  143.             case M_SOF1: 
  144.             case M_SOF2: 
  145.             case M_SOF3: 
  146.             case M_SOF5: 
  147.             case M_SOF6: 
  148.             case M_SOF7: 
  149.             case M_SOF9: 
  150.             case M_SOF10:
  151.             case M_SOF11:
  152.             case M_SOF13:
  153.             case M_SOF14:
  154.             case M_SOF15:
  155.                 process_SOFn(Data, marker);
  156.                 break;
  157.             default:
  158.                 // Skip any other sections.
  159.                 //if (ShowTags) printf("Jpeg section marker 0x%02x size %d\n",marker, itemlen);
  160.                 break;
  161.         }
  162.     }
  163. return 1;
  164. }

粗略分析Exif属性

FF D8 FF E0 00 10 4A 46 49 46 00 01 02 01 00 60
00 60   00 00 FF E1 08 32 45 78 69 66 00 00 49 49
2A 00 08 00 00 00   0B 00 0F 01 02 00 05 00 00 00
A2 00 00 00 10 01   02 00 20 00 00 00 A8 00 00 00
process_EXIF 
主要是对Exif属性做一个前期的处理，为了进一步详细的分析做处理。
由于EXIF是一种可交换的文件格式，所以可以用在Intel系列和Motorola系列的CPU上（至于两者CPU的区别，大家可以到网上找找，这里不做说明）。在文件中有一个标志，如果是“MM”表示Motorola的CPU，否则为“II”表示Intel的CPU。
 49 49  表示的是小端，小端的时候要格外注意其取字符的时候是从后往前取，才能获得正确的数据。
 4D 4D  表示的是大端
2A 00 表示的是检查下面 2 个字节是否是 0x2A00
08 00 00 00 判断下面的 0th IFD Offset 是否是 0x08000000

  1. ////////////////////////////////////////////////////////////////////////////////
  2. /*--------------------------------------------------------------------------
  3.    Process a EXIF marker
  4.    Describes all the drivel that most digital cameras include...
  5. --------------------------------------------------------------------------*/
  6. bool Cexif::process_EXIF(unsigned char * CharBuf, unsigned int length)
  7. {
  8.     m_exifinfo->FlashUsed = 0; 
  9.     /* If it's from a digicam, and it used flash, it says so. */
  10.     m_exifinfo->Comments[0] = '\0';  /* Initial value - null string */
  12.     ExifImageWidth = 0;
  14.     {   /* Check the EXIF header component */
  15.         static const unsigned char ExifHeader[] = "Exif\0\0";
  16.         if (memcmp(CharBuf+0, ExifHeader,6)){
  17. strcpy(m_szLastError,"Incorrect Exif header");
  18. return 0;
  19. }
  20.     }
  22.     if (memcmp(CharBuf+6,"II",2) == 0){
  23.         MotorolaOrder = 0;
  24.     }else{
  25.         if (memcmp(CharBuf+6,"MM",2) == 0){
  26.             MotorolaOrder = 1;
  27.         }else{
  28.             strcpy(m_szLastError,"Invalid Exif alignment marker.");
  29. return 0;
  30.         }
  31.     }
  33.     /* Check the next two values for correctness. */
  34.     if (Get16u(CharBuf+8) != 0x2a){
  35.         strcpy(m_szLastError,"Invalid Exif start (1)");
  36. return 0;
  37.     }
  39. int FirstOffset = Get32u(CharBuf+10);
  40.     if (FirstOffset < 8 || FirstOffset > 16){
  41.         // I used to ensure this was set to 8 (website I used indicated its 8)
  42.         // but PENTAX Optio 230 has it set differently, and uses it as offset. (Sept 11 2002)
  43.         strcpy(m_szLastError,"Suspicious offset of first IFD value");
  44. return 0;
  45.     }
  47.     unsigned char * LastExifRefd = CharBuf;
  49.     /* First directory starts 16 unsigned chars in.  Offsets start at 8 unsigned chars in. */
  50.     if (!ProcessExifDir(CharBuf+14, CharBuf+6, length-6, m_exifinfo, &LastExifRefd))
  51. return 0;
  53.     /* This is how far the interesting (non thumbnail) part of the exif went. */
  54.     // int ExifSettingsLength = LastExifRefd - CharBuf;
  56.     /* Compute the CCD width, in milimeters. */
  57.     if (m_exifinfo->FocalplaneXRes != 0){
  58.         m_exifinfo->CCDWidth = (float)(ExifImageWidth * m_exifinfo->FocalplaneUnits / m_exifinfo->FocalplaneXRes);
  59.     }
  61. return 1;
  62. }

详细分析Exif属性

FF D8 FF E0 00 10 4A 46 49 46 00 01 02 01 00 60
00 60   00 00 FF E1 08 32 45 78 69 66 00 00 49 49
2A 00 08 00 00 00   0B 00 0F 01 02 00 05 00 00 00
A2 00 00 00 10 01   02 00 20 00 00 00 A8 00 00 00

0B 00  Tag总共的数量，12个， 00 0B, 所以下面就主要围绕这个12个tag来寻找其属性
一个tag的格式就是：
Tag 类型名
Format: 格式，tag TYPE
count:   最多的字符个数为
offset: 偏移量，但是这里的偏移量要记得加上从（II  49 49）+1D

按照第一个实例：

                                           0F 01 02 00 05 00 00 00
A2 00 00 00 10 01   02 00 20 00 00 00 A8 00 00 00

Tag  0F 01     TAG Image input equipment manuf 
Format: 格式， 02 00， 格式为2
count:   05 00 00 00  为5
offset: 偏移量，A2 00 00 00 +1D  ，需要移动到 C0
*LastExifRefdP=ValuePtr+BytesCount;获取获得数据的 46 4C 49 52  

一次类推获得相关的tag数据，都是这样获得。关于GPS信息的话，且听下回分解。
  1. /*--------------------------------------------------------------------------
  2.    Process one of the nested EXIF directories.
  3. --------------------------------------------------------------------------*/
  4. bool Cexif::ProcessExifDir(unsigned char * DirStart, unsigned char * OffsetBase, unsigned ExifLength,
  5.                            EXIFINFO * const m_exifinfo, unsigned char ** const LastExifRefdP )
  6. {
  7.     int de;
  8.     int a;
  9.     int NumDirEntries;
  10.     unsigned ThumbnailOffset = 0;
  11.     unsigned ThumbnailSize = 0;
  13.     NumDirEntries = Get16u(DirStart);
  15.     if ((DirStart+2+NumDirEntries*12) > (OffsetBase+ExifLength)){
  16.         strcpy(m_szLastError,"Illegally sized directory");
  17. return 0;
  18.     }
  20.     for (de=0;de<NumDirEntries;de++){
  21.         int Tag, Format, Components;
  22.         unsigned char * ValuePtr;
  23.             /* This actually can point to a variety of things; it must be
  24.                cast to other types when used.  But we use it as a unsigned char-by-unsigned char
  25.                cursor, so we declare it as a pointer to a generic unsigned char here.
  26.             */
  27.         int BytesCount;
  28.         unsigned char * DirEntry;
  29.         DirEntry = DirStart+2+12*de;
  31.         Tag = Get16u(DirEntry);
  32.         Format = Get16u(DirEntry+2);
  33.         Components = Get32u(DirEntry+4);
  35.         if ((Format-1) >= NUM_FORMATS) {
  36.             /* (-1) catches illegal zero case as unsigned underflows to positive large */
  37.             strcpy(m_szLastError,"Illegal format code in EXIF dir");
  38. return 0;
  39. }
  41.         BytesCount = Components * BytesPerFormat[Format];
  43.         if (BytesCount > 4){
  44.             unsigned OffsetVal;
  45.             OffsetVal = Get32u(DirEntry+8);
  46.             /* If its bigger than 4 unsigned chars, the dir entry contains an offset.*/
  47.             if (OffsetVal+BytesCount > ExifLength){
  48.                 /* Bogus pointer offset and / or unsigned charcount value */
  49.                 strcpy(m_szLastError,"Illegal pointer offset value in EXIF.");
  50. return 0;
  51.             }
  52.             ValuePtr = OffsetBase+OffsetVal;
  53.         }else{
  54.             /* 4 unsigned chars or less and value is in the dir entry itself */
  55.             ValuePtr = DirEntry+8;
  56.         }
  58.         if (*LastExifRefdP < ValuePtr+BytesCount){
  59.             /* Keep track of last unsigned char in the exif header that was
  60.                actually referenced.  That way, we know where the
  61.                discardable thumbnail data begins.
  62.             */
  63.             *LastExifRefdP = ValuePtr+BytesCount;
  64.         }
  66.         /* Extract useful components of tag */
  67.         switch(Tag){
  69.             case TAG_MAKE:
  70.                 strncpy(m_exifinfo->CameraMake, (char*)ValuePtr, 31);
  71.                 break;
  73.             case TAG_MODEL:
  74.                 strncpy(m_exifinfo->CameraModel, (char*)ValuePtr, 39);
  75.                 break;
  77. case TAG_EXIF_VERSION:
  78. strncpy(m_exifinfo->Version,(char*)ValuePtr, 4);
  79. break;
  81.             case TAG_DATETIME_ORIGINAL:
  82.                 strncpy(m_exifinfo->DateTime, (char*)ValuePtr, 19);
  83.                 break;
  85.             case TAG_USERCOMMENT:
  86.                 // Olympus has this padded with trailing spaces. Remove these first. 
  87.                 for (a=BytesCount;;){
  88.                     a--;
  89.                     if (((char*)ValuePtr)[a] == ' '){
  90.                         ((char*)ValuePtr)[a] = '\0';
  91.                     }else{
  92.                         break;
  93.                     }
  94.                     if (a == 0) break;
  95.                 }
  97.                 /* Copy the comment */
  98.                 if (memcmp(ValuePtr, "ASCII",5) == 0){
  99.                     for (a=5;a<10;a++){
  100.                         char c;
  101.                         c = ((char*)ValuePtr)[a];
  102.                         if (c != '\0' && c != ' '){
  103.                             strncpy(m_exifinfo->Comments, (char*)ValuePtr+a, 199);
  104.                             break;
  105.                         }
  106.                     }
  107.                     
  108.                 }else{
  109.                     strncpy(m_exifinfo->Comments, (char*)ValuePtr, 199);
  110.                 }
  111.                 break;
  113.             case TAG_FNUMBER:
  114.                 /* Simplest way of expressing aperture, so I trust it the most.
  115.                    (overwrite previously computd value if there is one)
  116.                    */
  117.                 m_exifinfo->ApertureFNumber = (float)ConvertAnyFormat(ValuePtr, Format);
  118.                 break;
  120.             case TAG_APERTURE:
  121.             case TAG_MAXAPERTURE:
  122.                 /* More relevant info always comes earlier, so only
  123.                  use this field if we don't have appropriate aperture
  124.                  information yet. 
  125.                 */
  126.                 if (m_exifinfo->ApertureFNumber == 0){
  127.                     m_exifinfo->ApertureFNumber = (float)exp(ConvertAnyFormat(ValuePtr, Format)*log(2)*0.5);
  128.                 }
  129.                 break;
  131. case TAG_BRIGHTNESS:
  132. m_exifinfo->Brightness = (float)ConvertAnyFormat(ValuePtr, Format);
  133. break;
  135.             case TAG_FOCALLENGTH:
  136.                 /* Nice digital cameras actually save the focal length
  137.                    as a function of how farthey are zoomed in. 
  138.                 */
  140.                 m_exifinfo->FocalLength = (float)ConvertAnyFormat(ValuePtr, Format);
  141.                 break;
  143.             case TAG_SUBJECT_DISTANCE:
  144.                 /* Inidcates the distacne the autofocus camera is focused to.
  145.                    Tends to be less accurate as distance increases.
  146.                 */
  147.                 m_exifinfo->Distance = (float)ConvertAnyFormat(ValuePtr, Format);
  148.                 break;
  150.             case TAG_EXPOSURETIME:
  151.                 /* Simplest way of expressing exposure time, so I
  152.                    trust it most.  (overwrite previously computd value
  153.                    if there is one) 
  154.                 */
  155.                 m_exifinfo->ExposureTime = 
  156.                     (float)ConvertAnyFormat(ValuePtr, Format);
  157.                 break;
  159.             case TAG_SHUTTERSPEED:
  160.                 /* More complicated way of expressing exposure time,
  161.                    so only use this value if we don't already have it
  162.                    from somewhere else.  
  163.                 */
  164.                 if (m_exifinfo->ExposureTime == 0){
  165.                     m_exifinfo->ExposureTime = (float)
  166.                         (1/exp(ConvertAnyFormat(ValuePtr, Format)*log(2)));
  167.                 }
  168.                 break;
  170.             case TAG_FLASH:
  171.                 if ((int)ConvertAnyFormat(ValuePtr, Format) & 7){
  172.                     m_exifinfo->FlashUsed = 1;
  173.                 }else{
  174.                     m_exifinfo->FlashUsed = 0;
  175.                 }
  176.                 break;
  178.             case TAG_ORIENTATION:
  179.                 m_exifinfo->Orientation = (int)ConvertAnyFormat(ValuePtr, Format);
  180.                 if (m_exifinfo->Orientation < 1 || m_exifinfo->Orientation > 8){
  181.                     strcpy(m_szLastError,"Undefined rotation value");
  182.                     m_exifinfo->Orientation = 0;
  183.                 }
  184.                 break;
  186.             case TAG_EXIF_IMAGELENGTH:
  187.             case TAG_EXIF_IMAGEWIDTH:
  188.                 /* Use largest of height and width to deal with images
  189.                    that have been rotated to portrait format.  
  190.                 */
  191.                 a = (int)ConvertAnyFormat(ValuePtr, Format);
  192.                 if (ExifImageWidth < a) ExifImageWidth = a;
  193.                 break;
  195.             case TAG_FOCALPLANEXRES:
  196.                 m_exifinfo->FocalplaneXRes = (float)ConvertAnyFormat(ValuePtr, Format);
  197.                 break;
  199.             case TAG_FOCALPLANEYRES:
  200.                 m_exifinfo->FocalplaneYRes = (float)ConvertAnyFormat(ValuePtr, Format);
  201.                 break;
  203. case TAG_RESOLUTIONUNIT:
  204.                 switch((int)ConvertAnyFormat(ValuePtr, Format)){
  205.                     case 1: m_exifinfo->ResolutionUnit = 1.0f; break; /* 1 inch */
  206.                     case 2:m_exifinfo->ResolutionUnit = 1.0f; break;
  207.                     case 3: m_exifinfo->ResolutionUnit = 0.3937007874f;    break;  /* 1 centimeter*/
  208.                     case 4: m_exifinfo->ResolutionUnit = 0.03937007874f;   break;  /* 1 millimeter*/
  209.                     case 5: m_exifinfo->ResolutionUnit = 0.00003937007874f;  /* 1 micrometer*/
  210.                 }
  211.                 break;
  213.             case TAG_FOCALPLANEUNITS:
  214.                 switch((int)ConvertAnyFormat(ValuePtr, Format)){
  215.                     case 1: m_exifinfo->FocalplaneUnits = 1.0f; break; /* 1 inch */
  216.                     case 2:m_exifinfo->FocalplaneUnits = 1.0f; break;
  217.                     case 3: m_exifinfo->FocalplaneUnits = 0.3937007874f;    break;  /* 1 centimeter*/
  218.                     case 4: m_exifinfo->FocalplaneUnits = 0.03937007874f;   break;  /* 1 millimeter*/
  219.                     case 5: m_exifinfo->FocalplaneUnits = 0.00003937007874f;  /* 1 micrometer*/
  220.                 }
  221.                 break;
  223.                 // Remaining cases contributed by: Volker C. Schoech <schoech(at)gmx(dot)de>
  225.             case TAG_EXPOSURE_BIAS:
  226.                 m_exifinfo->ExposureBias = (float) ConvertAnyFormat(ValuePtr, Format);
  227.                 break;
  229.             case TAG_WHITEBALANCE:
  230.                 m_exifinfo->Whitebalance = (int)ConvertAnyFormat(ValuePtr, Format);
  231.                 break;
  233.             case TAG_METERING_MODE:
  234.                 m_exifinfo->MeteringMode = (int)ConvertAnyFormat(ValuePtr, Format);
  235.                 break;
  237.             case TAG_EXPOSURE_PROGRAM:
  238.                 m_exifinfo->ExposureProgram = (int)ConvertAnyFormat(ValuePtr, Format);
  239.                 break;
  241.             case TAG_ISO_EQUIVALENT:
  242.                 m_exifinfo->ISOequivalent = (int)ConvertAnyFormat(ValuePtr, Format);
  243.                 if ( m_exifinfo->ISOequivalent < 50 ) m_exifinfo->ISOequivalent *= 200;
  244.                 break;
  246.             case TAG_COMPRESSION_LEVEL:
  247.                 m_exifinfo->CompressionLevel = (int)ConvertAnyFormat(ValuePtr, Format);
  248.                 break;
  250.             case TAG_XRESOLUTION:
  251.                 m_exifinfo->Xresolution = (float)ConvertAnyFormat(ValuePtr, Format);
  252.                 break;
  253.             case TAG_YRESOLUTION:
  254.                 m_exifinfo->Yresolution = (float)ConvertAnyFormat(ValuePtr, Format);
  255.                 break;
  257.             case TAG_THUMBNAIL_OFFSET:
  258.                 ThumbnailOffset = (unsigned)ConvertAnyFormat(ValuePtr, Format);
  259.                 break;
  261.             case TAG_THUMBNAIL_LENGTH:
  262.                 ThumbnailSize = (unsigned)ConvertAnyFormat(ValuePtr, Format);
  263.                 break;
  265.         }
  267.         if (Tag == TAG_EXIF_OFFSET || Tag == TAG_INTEROP_OFFSET){
  268.             unsigned char * SubdirStart;
  269.             SubdirStart = OffsetBase + Get32u(ValuePtr);
  270.             if (SubdirStart < OffsetBase || 
  271.                 SubdirStart > OffsetBase+ExifLength){
  272.                 strcpy(m_szLastError,"Illegal subdirectory link");
  273. return 0;
  274.             }
  275.             ProcessExifDir(SubdirStart, OffsetBase, ExifLength, m_exifinfo, LastExifRefdP);
  276.             continue;
  277.         }
  278.     }
  281.     {
  282.         /* In addition to linking to subdirectories via exif tags,
  283.            there's also a potential link to another directory at the end
  284.            of each directory.  This has got to be the result of a
  285.            committee!  
  286.         */
  287.         unsigned char * SubdirStart;
  288.         unsigned Offset;
  289.         Offset = Get16u(DirStart+2+12*NumDirEntries);
  290.         if (Offset){
  291.             SubdirStart = OffsetBase + Offset;
  292.             if (SubdirStart < OffsetBase 
  293.                 || SubdirStart > OffsetBase+ExifLength){
  294.                 strcpy(m_szLastError,"Illegal subdirectory link");
  295. return 0;
  296.             }
  297.             ProcessExifDir(SubdirStart, OffsetBase, ExifLength, m_exifinfo, LastExifRefdP);
  298.         }
  299.     }
  302.     if (ThumbnailSize && ThumbnailOffset){
  303.         if (ThumbnailSize + ThumbnailOffset <= ExifLength){
  304.             /* The thumbnail pointer appears to be valid.  Store it. */
  305.             m_exifinfo->ThumbnailPointer = OffsetBase + ThumbnailOffset;
  306.             m_exifinfo->ThumbnailSize = ThumbnailSize;
  307.         }
  308.     }
  310. return 1;
  311. }

Demo最终实现的结果


参考文档

http://blog.csdn.net/fioletfly/article/details/53605959
http://blog.csdn.net/xuan_oscar/article/details/2449624





0 1
情头软件即刻 情头软件即刻
原创粉丝点击
热门IT博客
淘宝助理怎么用不了淘宝助理怎么用不了
青年网络公开课第二期青年网络公开课第二期
买3DS淘宝哪个好
java三层架构是什么
adobe全部软件介绍
淘宝制图用什么软件
手机cpu监控软件
其是之谓乎翻译
网络教育几月发毕业证
索尼z5 premium优化
linux 70秒漏洞
mac app store dns
小米电视软件安装
unity3d开发的vr游戏
rightfont for mac
arm编程用什么语言
全球第一大社交网络
sql natural join
淘宝网首页连衣裙
js encodeuri 调用两次
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 脚指甲边化脓了怎么办 甲沟炎肿了流脓怎么办 脚趾甲变黄变厚怎么办 脚指甲一半变黄怎么办 指甲变白变空怎么办 脚指甲变白变空怎么办 脚趾甲变厚变黄怎么办 脚趾甲发白变空怎么办 指甲空了一半怎么办 脚大拇指甲变厚怎么办 脚趾甲变厚还疼怎么办 手指甲上有白点怎么办 广电机顶盒坏了怎么办 嘴唇边缘颜色深怎么办 脑囊虫钙化灶怎么办 下肢肌张力高怎么办 肺癌咳嗽有血丝怎么办 躺下嗓子痒咳嗽怎么办 背后中间脊柱疼怎么办 后背中间脊柱疼怎么办 后背脊柱骨头疼怎么办 画画久坐背疼怎么办 背疼有点弯怎么办 背上总是长粉刺怎么办 新生儿嘴唇起皮怎么办 小婴儿老是哭闹怎么办 新生儿一直哭怎么办啊 新生儿夜哭厉害怎么办 新生儿宝贝夜哭怎么办 新生儿小孩夜哭怎么办 婴儿哭夜厉害怎么办 小婴儿哭闹不止怎么办 20天新生儿哭闹怎么办 新生儿吓着了怎么办 新生儿嗓子哑了怎么办 新生儿哭嗓子哑怎么办 嘴唇干裂怎么办小秘方 下嘴唇长溃疡怎么办 嘴唇上火烂了怎么办 婴儿睡觉打惊怎么办 心慌气短胸闷是怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里