数码照片的文件高级信息获取

////调用

string strfile = "fffff.jpg";//文件名

System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(strfile);

exif.exifextractor er = new exif.exifextractor(ref bmp, " ");

string a = strfile + "</br>";

foreach (exif.pair pr in er)

{

a += pr.first + ":" + pr.second + "<br />";

}

div1.InnerHtml = a;
--------------------------------------------------------------------------------------------------------------------------

translation类：

using System;

using System.Collections.Generic;

using System.Collections;

using System.Text;

namespace exif

{

/// <summary>

/// summary description for translation.

/// </summary>

public class translation : Hashtable

{

/// <summary>

///

/// </summary>

public translation()

{

this.Add(0x8769, "exif ifd_Exif 子IFD的偏移量");//Exif 子IFD的偏移量

this.Add(0x8825, "gps ifd");//GPSInfo

this.Add(0xfe, "new subfile type");//NewSubfileType

this.Add(0xff, "subfile type");//SubfileType

//表示缩略图的大小.

this.Add(0x100, "image width_缩略图的大小");

this.Add(0x101, "image height_缩略图的大小");

this.Add(0x102, "bits per sample_当图像格式没有经过压缩, 这个值表示每像素的比特位的数目");//当图像格式没有经过压缩, 这个值表示每像素的比特位的数目. 通常这个值是 '8,8,8'

this.Add(0x103, "compression_压缩的方式");//代表压缩的方式. '1' 表示非压缩, '6' 表示JPEG 压缩格式.

this.Add(0x106, "photometric interp_图像数据组件的色彩空间");//表示图像数据组件的色彩空间. '1' 意味着单色, '2'表示 RGB, '6' 表示 YCbCr.

this.Add(0x107, "thresh holding");

this.Add(0x108, "cell width");

this.Add(0x109, "cell height");

this.Add(0x10a, "fill order");

this.Add(0x10d, "document name");

this.Add(0x10e, "image description_描述图像");//用来描述图像. 双字节的字符码不能使用, 如中文/韩文/日文.

this.Add(0x10f, "equip make_数字相机的制造商");//表示数字相机的制造商. 在 Exif 标准中, 这个标签是可选的, 但是在DCF中它是必需的.

this.Add(0x110, "equip model_数字相机的模块代码");//表示数字相机的模块代码. 在 Exif 标准中, 这个标签是可选的, 但在DCF中它也是必需的.

this.Add(0x111, "strip offsets_图像数据的偏移量");//如果图像格式没有经过压缩, 这个值表示的是到图像数据的偏移量. 在图像数据被分割的情况下它有多个值.

//当拍照时, 相机相对于场景的方向. 在右边表示的是'0th row' 以及 '0th column' 在视觉位置上的关系.

//Value|0th Row |0th Column

//1 |top |left side

//2 |top |right side

//3 |bottom |right side

//4 |bottom |left side

//5 |left side |top

//6 |right side|top

//7 |right side|bottom

//8 |left side |bottom

this.Add(0x112, "orientation_相机相对于场景的方向");

this.Add(0x115, "samples perpixel_每个像素中存储的组件数目");//如果图像格式没有经过压缩, 这个值表示每个像素中存储的组件数目. 在彩色图像中, 此值为 '3'.

this.Add(0x116, "rows per strip_每条数据带存储了多少行数据");//如果图像格式没有经过压缩并且图像被分割存储, 这个值表示每条数据带存储了多少行数据 . 如果图像没有被分割, 它与ImageLength(0x0101)同值.

this.Add(0x117, "strip bytes count_每条数据带使用了多少字节的数据且有多个值");//如果图像格式没有经过压缩并且图像被分割存储, 这个值表示每条数据带使用了多少字节的数据且有多个值. 如果图像没有被分割, 它只有一个且表示为图像的所有数据的大小.

this.Add(0x118, "min sample value");

this.Add(0x119, "max sample value");

//图像的显示/打印分辨率. 缺省值是 1/72英寸, 但是它没有意义因为个人PC在显示/打印图像的时候不使用这个值.

this.Add(0x11a, "x resolution_图像的显示/打印分辨率");

this.Add(0x11b, "y resolution_图像的显示/打印分辨率");

this.Add(0x11c, "planar config_YCbCr数据的字节对齐顺序");//如果图像格式是非压缩YCbCr的, 这个值表示YCbCr数据的字节对齐顺序. '1', 表示Y/Cb/Cr值是一个 chunky format, 对于每个子采样像素都是连续的. '2', 则表示Y/Cb/Cr 值被分割存储在 Y plane/Cb plane/Cr plane 格式中.

this.Add(0x11d, "page name");

this.Add(0x11e, "x position");

this.Add(0x11f, "y position");

this.Add(0x120, "free offset");

this.Add(0x121, "free byte counts");

this.Add(0x122, "gray response unit");

this.Add(0x123, "gray response curve");

this.Add(0x124, "t4 option");

this.Add(0x125, "t6 option");

this.Add(0x128, "resolution unit_分辨率单位");//XResolution(0x011a)/YResolution(0x011b)的单位. '1' 表示没有单位, '2' 意味着英寸, '3' 表示厘米. 缺省值是 '2'(英寸).

this.Add(0x129, "page number");

this.Add(0x12d, "transfer funcition");

this.Add(0x131, "software used_显示固件的版本号");//显示固件的版本号(数字相机的内部控制软件).

this.Add(0x132, "date time_图像最后一次被修改时的日期/时间");//图像最后一次被修改时的日期/时间. 日期的格式是 "YYYY:MM:DD HH:MM:SS"+0x00, 一共 20个字节. 如果没有设置时钟或者数字相机没有时钟, 则这个域是用空格来填充. 通常, 它和DateTimeOriginal(0x9003)具有相同的值

this.Add(0x13b, "artist");

this.Add(0x13c, "host computer");

this.Add(0x13d, "predictor");

this.Add(0x13e, "white point_定义图像白点");//定义图像白点(white point/白点：在彩色分色、照相或摄影时作为色彩平衡测量用途的参考点) 的色度(chromaticity). 如果图像是用CIE标准照度 D65(著名的是 '光线/daylight'的国际标准), 这个值是 '3127/10000,3290/10000'.

this.Add(0x13f, "primary chromaticities_定义图像的原始色度");//定义图像的原始色度. 如果图像使用 CCIR 推荐 709原始色度, 则这个值是 '640/1000,330/1000,300/1000,600/1000,150/1000,0/1000'.

this.Add(0x140, "colormap");

this.Add(0x141, "halftone hints");

this.Add(0x142, "tile width");

this.Add(0x143, "tile length");

this.Add(0x144, "tile offset");

this.Add(0x145, "tile bytecounts");

this.Add(0x14c, "inkset");

this.Add(0x14d, "ink names");

this.Add(0x14e, "number of inks");

this.Add(0x150, "dot range");

this.Add(0x151, "target printer");

this.Add(0x152, "extra samples");

this.Add(0x153, "sample format");

this.Add(0x154, "s min sample value");

this.Add(0x155, "s max sample value");

this.Add(0x156, "transfer range");

this.Add(0x200, "jpeg proc_照片的拍摄模式");//表示照片的拍摄模式. 第一个值的意思是 0=正常, 1=未知, 2=快速, 3=全景. 第二个值意思是序列号, 第三个值表示全景的方向 1=从左到右, 2=从右到左, 3=从下到上, 4=从上到下.

this.Add(0x201, "jpeg interformat_到 JPEG 数据的偏移量");//当图像格式是JPEG时, 这个值表示到 JPEG 数据的偏移量.

this.Add(0x202, "jpeg interlength_JPEG 图像的数据大小");//当图像格式是JPEG时, 表示JPEG 图像的数据大小.

this.Add(0x203, "jpeg restartinterval");

this.Add(0x205, "jpeg losslesspredictors");

this.Add(0x206, "jpeg pointtransforms");

this.Add(0x207, "jpeg qtables_固件版本");//表示固件版本.

this.Add(0x208, "jpeg dctables_包含 ASCII 格式的数据");//包含 ASCII 格式的数据如 [PictureInfo]. 它跟老的奥林帕斯数码相机(没有采用Exif 数据格式, 如C1400/C820/D620/D340等)采用相同的数据格式.

this.Add(0x209, "CameraID 的数据");//包含CameraID 的数据, 用户可以使用客户端工具来改变它的内容

this.Add(0x211, "ycbcr coefficients_转换成 RGB格式的一个常量");//当图像的格式是 YCbCr(JPEG的格式), 这个值表示转换成 RGB格式的一个常量. 通常, 这个值是'0.299/0.587/0.114'.

this.Add(0x212, "ycbcr subsampling_有多少个色度数据被采样了");//当图像格式是YCbCr时并且使用子采样(色度数据的剪切值, 所有的数字相机都使用)时, 这个值表示有多少个色度数据被采样了. 首先第一个值表示水平的, 下一个值表示垂直的采样率.

this.Add(0x213, "ycbcr positioning_定义了被采样的像素阵列的色度采样点");//当图像格式是YCbCr时并且使用子采样(色度数据的剪切值, 所有的数字相机都使用)时, 这个值定义了被采样的像素阵列的色度采样点. '1' 表示像素阵列的中心, '2' 表示基准点(0,0).

this.Add(0x214, "ref black white_黑点/白点的参考值");//表示黑点/白点的参考值. 在 YCbCr 格式的情况下, 前两个表示了Y的黑/白, 下两个是 Cb, 最后两个是 Cr. 在 RGB 的情况下, 前两个表示R的黑/白, 下两个是 G, 最后两个是 B.

this.Add(0x8773, "icc profile");

this.Add(0x301, "gamma");

this.Add(0x302, "icc profile descriptor");

this.Add(0x303, "srgb renderingintent");

this.Add(0x320, "image title");

this.Add(0x8298, "copyright_版权信息");//表示版权信息

this.Add(0x5001, "resolution x unit");

this.Add(0x5002, "resolution y unit");

this.Add(0x5003, "resolution x lengthunit");

this.Add(0x5004, "resolution y lengthunit");

this.Add(0x5005, "print flags");

this.Add(0x5006, "print flags version");

this.Add(0x5007, "print flags crop");

this.Add(0x5008, "print flags bleed width");

this.Add(0x5009, "print flags bleed width scale");

this.Add(0x500a, "halftone lpi");

this.Add(0x500b, "halftone lpiunit");

this.Add(0x500c, "halftone degree");

this.Add(0x500d, "halftone shape");

this.Add(0x500e, "halftone misc");

this.Add(0x500f, "halftone screen");

this.Add(0x5010, "jpeg quality");

this.Add(0x5011, "grid size");

this.Add(0x5012, "thumbnail format");

this.Add(0x5013, "thumbnail width");

this.Add(0x5014, "thumbnail height");

this.Add(0x5015, "thumbnail colordepth");

this.Add(0x5016, "thumbnail planes");

this.Add(0x5017, "thumbnail rawbytes");

this.Add(0x5018, "thumbnail size");

this.Add(0x5019, "thumbnail compressedsize");

this.Add(0x501a, "color transfer function");

this.Add(0x501b, "thumbnail data");

this.Add(0x5020, "thumbnail imagewidth");

this.Add(0x502, "thumbnail imageheight");

this.Add(0x5022, "thumbnail bitspersample");

this.Add(0x5023, "thumbnail compression");

this.Add(0x5024, "thumbnail photometricinterp");

this.Add(0x5025, "thumbnail imagedescription");

this.Add(0x5026, "thumbnail equipmake");

this.Add(0x5027, "thumbnail equipmodel");

this.Add(0x5028, "thumbnail stripoffsets");

this.Add(0x5029, "thumbnail orientation");

this.Add(0x502a, "thumbnail samplesperpixel");

this.Add(0x502b, "thumbnail rowsperstrip");

this.Add(0x502c, "thumbnail stripbytescount");

this.Add(0x502d, "thumbnail resolutionx");

this.Add(0x502e, "thumbnail resolutiony");

this.Add(0x502f, "thumbnail planarconfig");

this.Add(0x5030, "thumbnail resolutionunit");

this.Add(0x5031, "thumbnail transferfunction");

this.Add(0x5032, "thumbnail softwareused");

this.Add(0x5033, "thumbnail datetime");

this.Add(0x5034, "thumbnail artist");

this.Add(0x5035, "thumbnail whitepoint");

this.Add(0x5036, "thumbnail primarychromaticities");

this.Add(0x5037, "thumbnail ycbcrcoefficients");

this.Add(0x5038, "thumbnail ycbcrsubsampling");

this.Add(0x5039, "thumbnail ycbcrpositioning");

this.Add(0x503a, "thumbnail refblackwhite");

this.Add(0x503b, "thumbnail copyright");

this.Add(0x5090, "luminance table");

this.Add(0x5091, "chrominance table");

this.Add(0x5100, "frame delay");

this.Add(0x5101, "loop count");

this.Add(0x5110, "pixel unit");

this.Add(0x5111, "pixel perunit x");

this.Add(0x5112, "pixel perunit y");

this.Add(0x5113, "palette histogram");

this.Add(0x829a, "exposure time_曝光时间");//曝光时间 (快门速度的倒数). 单位是秒.

this.Add(0x829d, "f-number_拍照时的光圈");//拍照时的光圈F-number(F-stop).

this.Add(0x8822, "exposure prog_拍照时相机使用的曝光程序");//拍照时相机使用的曝光程序. '1' 表示手动曝光, '2' 表示正常程序曝光, '3' 表示光圈优先曝光, '4' 表示快门优先曝光, '5' 表示创意程序(慢速程序), '6' 表示动作程序(高速程序), '7'表示肖像模式, '8' 表示风景模式.

this.Add(0x8824, "spectral sense");

this.Add(0x8827, "iso speed_CCD 的感光度");//CCD 的感光度, 等效于 Ag-Hr 胶片的速率.

this.Add(0x8828, "oecf");

this.Add(0x9000, "ver_Exif 的版本号");//Exif 的版本号. 用4个ASCII字符来存储. 如果图片是基于Exif V2.1的, 这个值是 "0210". 因为它不是一个用NULL(0x00)来终结的字符串，所以这里的类型是 'undefined'.

this.Add(0x9003, "dtorig_照片在被拍下来的日期/时间");//照片在被拍下来的日期/时间. 使用用户的软件是不能被修改这个值的. 日期的格式是 "YYYY:MM:DD HH:MM:SS"+0x00, 一共占用20个字节. 如果数字相机没有设置时钟或者数字相机没有时钟, 这个域使用空格来填充. 在Exif标准中, 这个标签是可选的, 但是在 DCF中是必需的.

this.Add(0x9004, "dtdigitized_照片被数字化时的日期/时间");//照片被数字化时的日期/时间. 通常, 它与DateTimeOriginal(0x9003)具有相同的值. 数据格式是 "YYYY:MM:DD HH:MM:SS"+0x00, 一共占用20个字节. 如果数字相机没有设置时钟或者数字相机没有时钟, 这个域使用空格来填充. 在Exif标准中, 这个标签是可选的, 但是在 DCF中是必需的.

this.Add(0x9101, "compconfig_像素数据的顺序");//表示的是像素数据的顺序. 大多数情况下RGB格式使用 '0x04,0x05,0x06,0x00' 而YCbCr 格式使用 '0x01,0x02,0x03,0x00'. 0x00:并不存在, 其他的对应关系为 0x01:Y, 0x02:Cb, 0x03:Cr, 0x04:Red, 0x05:Green, 0x06:Bllue.

this.Add(0x9102, "compbpp_平均压缩率");//JPEG (粗略的估计)的平均压缩率.

this.Add(0x9201, "shutter speed_出的快门速度");//用APEX表示出的快门速度. 为了转换成原始的 'Shutter Speed'; 则先要计算2的ShutterSpeedValue次幂, 然后求倒数. 例如, 如果 ShutterSpeedValue 是 '4', 快门速度则是1/(24)=1/16秒.

this.Add(0x9202, "aperture_拍照时镜头的光圈");//拍照时镜头的光圈. 单位是 APEX. 为了转换成普通的 F-number(F-stop), 则要先计算出根号2 2 (=1.4142)的ApertureValue次幂. 例如, 如果ApertureValue 是 '5', F-number 就等于1.41425 = F5.6.

this.Add(0x9203, "brightness_被拍摄对象的明度");//被拍摄对象的明度, 单位是 APEX. 为了从BrigtnessValue(Bv)计算出曝光量(Ev), 你必须加上 SensitivityValue(Sv). Ev=Bv+Sv Sv=log2(ISOSpeedRating/3.125) ISO100:Sv=5, ISO200:Sv=6, ISO400:Sv=7, ISO125:Sv=5.32.

this.Add(0x9204, "exposure bias_照片拍摄时的曝光补偿");//照片拍摄时的曝光补偿. 单位是APEX(EV).

this.Add(0x9205, "maxaperture_镜头的最大光圈值");//镜头的最大光圈值. 你可以通过计算根号2的MaxApertureValue次幂来转换成普通的光圈 F-number (跟ApertureValue:0x9202的处理过程一样).

this.Add(0x9206, "subjectdist_到焦点的距离");//到焦点的距离, 单位是米.

this.Add(0x9207, "metering mode_曝光的测光方法");//曝光的测光方法. '0' 表示未知, '1' 为平均测光, '2' 为中央重点测光, '3' 是点测光, '4' 是多点测光, '5' 是多区域测光, '6' 部分测光, '255' 则是其他.

this.Add(0x9208, "lightsource_光源, 实际上是表示白平衡设置");//光源, 实际上是表示白平衡设置. '0' 意味着未知, '1'是日光, '2'是荧光灯, '3' 白炽灯(钨丝), '10' 闪光灯, '17' 标准光A, '18' 标准光B, '19' 标准光C, '20' D55, '21' D65, '22' D75, '255' 为其他.

this.Add(0x9209, "flash_闪光灯");//'0' 表示闪光灯没有闪光, '1' 表示闪光灯闪光, '5' 表示闪光但没有检测反射光, '7' 表示闪光且检测了反射光.

this.Add(0x920a, "focallength_拍摄照片时的镜头的焦距长度");//拍摄照片时的镜头的焦距长度. 单位是毫米.

this.Add(0x927c, "_maker note制造商的内部数据");//制造商的内部数据. 一些制造商如 Olympus/Nikon/Sanyo 等在这个区域中使用IFD 格式的数据.

//存储用户的注释. 这个标签允许使用两字节的德字符或者 unicode. 前8 个字节描述的是字符集. 'JIS' 是日文 (著名的有 Kanji).

//'0x41,0x53,0x43,0x49,0x49,0x00,0x00,0x00':ASCII

//'0x4a,0x49,0x53,0x00,0x00,0x00,0x00,0x00':JIS

//'0x55,0x4e,0x49,0x43,0x4f,0x44,0x45,0x00':Unicode

//'0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00':Undefined

this.Add(0x9286, "user comment_存储用户的注释");

//一些数字相机每秒能拍摄 2~30 张照片, 但是DateTime/DateTimeOriginal/DateTimeDigitized 标签只能记录到秒单位的时间. SubsecTime 标签就是用来记录秒后面的数据(微秒).

//例如, DateTimeOriginal = "1996:09:01 09:15:30", SubSecTimeOriginal = "130", 合并起来的原始的拍摄时间就是 "1996:09:01 09:15:30.130"

this.Add(0x9290, "dtsubsec_拍摄微秒时间");

this.Add(0x9291, "dtorigss_拍摄微秒时间");

this.Add(0x9292, "dtdigss_拍摄微秒时间");

this.Add(0xa000, "fpxver_存储FlashPix 的版本信息");//存储FlashPix 的版本信息. 如果图像数据是基于 FlashPix formar Ver.1.0, 则这个值为 "0100". 因为它不是一个用NULL(0x00)来终结的字符串，所以这里的类型是 'undefined'.

this.Add(0xa001, "colorspace_定义色彩空间");//定义色彩空间. DCF 图像必须使用 sRGB 色彩空间因此这个值总是 '1'. 如果这个照片使用了其他的色彩空间, 这个值是 '65535':未校准(Uncalibrated).

//主图像的尺寸大小.

this.Add(0xa002, "pixxdim_主图像的尺寸大小Width");//ExifImageWidth

this.Add(0xa003, "pixydim_主图像的尺寸大小Height");//ExifImageHeight

this.Add(0xa004, "relatedwav_音频数据的名字");//如果数字相机能够纪录图像的音频数据, 则表示音频数据的名字.

this.Add(0xa005, "interop_扩展");//表示这是一个扩展"ExifR98", 细节未知. 这个值经常是IFD格式的数据. 当前这儿有两个目录项, 第一个是 Tag0x0001, 值是"R98", 下一个是 Tag0x0002, 它的值为 "0100".

this.Add(0xa20b, "flashenergy");

this.Add(0xa20c, "spatialfr");

//表示CCD的像素密度. 如果你的相机是百万像素的并且是用低分辨率(如VGA模式) 来拍摄照片, 这个值可以通过照片的分辨率来重新采样. 在这种情况下, FocalPlaneResolution 就不是CCD的实际的分辨率.

this.Add(0xa20e, "focalxres_CCD的像素密度");

this.Add(0xa20f, "focalyres_CCD的像素密度");

//FocalPlaneXResoluton/FocalPlaneYResolution的单位. '1' 表示没有单位, '2'是英寸inch, '3' 表示厘米.

//注意:一些Fujifilm的数码相机(如.FX2700,FX2900,Finepix4700Z/40i 等) 使用的值是 '3' 所以它的单位一定是 '厘米' , 但是它们的分辨率单位就变成'8.3mm?'(1/3in.?). 这是Fuji 的 BUG? 从Finepix4900Z 开始这个值就使用 '2' 了但仍然跟实际的值不吻合.

this.Add(0xa210, "focalresunit_FocalPlaneXResoluton/FocalPlaneYResolution的单位");

this.Add(0xa214, "subject loc");

this.Add(0xa215, "exposure index");//跟ISOSpeedRatings(0x8827)一样但是数据类型是 unsigned rational. 只有Kodak的数字相机使用这个标签来替代 ISOSpeedRating, 我不知道这是为什么(历史原因?).

this.Add(0xa217, "sensing method_图像传感器单元的类型");//表示图像传感器单元的类型. '2' 意味着这是一个芯片颜色区域传感器, 几乎所有的数字相机都使用这个类型.

this.Add(0xa300, "filesource_显示图像来源");//显示图像来源. 值 '0x03' 表示图像源是数字定格相机.

this.Add(0xa301, "scenetype_拍摄场景的类型");//表示拍摄场景的类型. 值 '0x01' 表示图像是通过相机直接拍摄出来的.

//表示色彩过滤阵列(CFA) 几何模式.

//长度类型意义

//2 shortHorizontal repeat pixel unit = n

//2 shortVertical repeat pixel unit = m

//1 byteCFA value[0,0]

//: : :

//1 byteCFA value[n-1,0]

//1 byteCFA value[0,1]

//: : :

//1 byteCFA value[n-1,m-1]

//色彩过滤和CFA值之间的关系.

//Filter ColorRedGreenBlueCyanMagentaYellowWhite

//CFA value 01 2 3 4 5 6

//RG例如, 普通的 RGB 过滤器使用左表的副本, 这个值是 '0x0002,0x0002,0x00,0x01,0x01,0x02'.

//GB

this.Add(0xa302, "cfapattern_色彩过滤阵列(CFA) 几何模式");

this.Add(0x0, "gps ver");

this.Add(0x1, "gps latituderef");

this.Add(0x2, "gps latitude");

this.Add(0x3, "gps longituderef");

this.Add(0x4, "gps longitude");

this.Add(0x5, "gps altituderef");

this.Add(0x6, "gps altitude");

this.Add(0x7, "gps gpstime");

this.Add(0x8, "gps gpssatellites");

this.Add(0x9, "gps gpsstatus");

this.Add(0xa, "gps gpsmeasuremode");

this.Add(0xb, "gps gpsdop");

this.Add(0xc, "gps speedref");

this.Add(0xd, "gps speed");

this.Add(0xe, "gps trackref");

this.Add(0xf, "gps track");

this.Add(0x10, "gps imgdirref_纪录图像文件的文件格式");//纪录图像文件的文件格式. 这个值是 ascii 字符串(如. "Exif JPEG Ver. 2.1").

this.Add(0x11, "gps imgdir");

this.Add(0x12, "gps mapdatum");

this.Add(0x13, "gps destlatref");

this.Add(0x14, "gps destlat");

this.Add(0x15, "gps destlongref");

//地址0x0016~0x0017处存放的数据为0x6987, 表示下一个标签是 ExifOffset(0x8769). 这就是指向 Exif子IFD的偏移量

this.Add(0x16, "gps destlong_指向 Exif子IFD的偏移量");

this.Add(0x17, "gps destbearref_指向 Exif子IFD的偏移量");

this.Add(0x18, "gps destbear");

this.Add(0x19, "gps destdistref");

this.Add(0x1a, "gps destdist");

}

/// <summary>

/// private class

/// </summary>

internal class rational

{

private int n;

private int d;

public rational(int n, int d)

{

this.n = n;

this.d = d;

simplify(ref this.n, ref this.d);

}

public rational(uint n, uint d)

{

this.n = Convert.ToInt32(n);

this.d = Convert.ToInt32(d);

simplify(ref this.n, ref this.d);

}

public rational()

{

this.n = this.d = 0;

}

public string tostring(string sp)

{

if (sp == null) sp = "/";

return n.ToString() + sp + d.ToString();

}

public double todouble()

{

if (d == 0)

return 0.0;

return Math.Round(Convert.ToDouble(n) / Convert.ToDouble(d), 2);

}

private void simplify(ref int a, ref int b)

{

if (a == 0 || b == 0)

return;

int gcd = euclid(a, b);

a /= gcd;

b /= gcd;

}

private int euclid(int a, int b)

{

if (b == 0)

return a;

else

return euclid(b, a % b);

}

--------------------------------------------------------------------------------------------------------------------------
exifextractor类：

using System;

using System.Text;

using System.Collections;

using System.Drawing.Imaging;

using System.Reflection;

using System.IO;

namespace exif

{

/// <summary>

/// exifextractor class

///

/// </summary>

public class exifextractor : IEnumerable

{

/// <summary>

/// get the individual property value by supplying property name

/// these are the valid property names :

///

/// "exif ifd"

/// "gps ifd"

/// "new subfile type"

/// "subfile type"

/// "image width"

/// "image height"

/// "bits per sample"

/// "compression"

/// "photometric interp"

/// "thresh holding"

/// "cell width"

/// "cell height"

/// "fill order"

/// "document name"

/// "image description"

/// "equip make"

/// "equip model"

/// "strip offsets"

/// "orientation"

/// "samples perpixel"

/// "rows per strip"

/// "strip bytes count"

/// "min sample value"

/// "max sample value"

/// "x resolution"

/// "y resolution"

/// "planar config"

/// "page name"

/// "x position"

/// "y position"

/// "free offset"

/// "free byte counts"

/// "gray response unit"

/// "gray response curve"

/// "t4 option"

/// "t6 option"

/// "resolution unit"

/// "page number"

/// "transfer funcition"

/// "software used"

/// "date time"

/// "artist"

/// "host computer"

/// "predictor"

/// "white point"

/// "primary chromaticities"

/// "colormap"

/// "halftone hints"

/// "tile width"

/// "tile length"

/// "tile offset"

/// "tile bytecounts"

/// "inkset"

/// "ink names"

/// "number of inks"

/// "dot range"

/// "target printer"

/// "extra samples"

/// "sample format"

/// "s min sample value"

/// "s max sample value"

/// "transfer range"

/// "jpeg proc"

/// "jpeg interformat"

/// "jpeg interlength"

/// "jpeg restartinterval"

/// "jpeg losslesspredictors"

/// "jpeg pointtransforms"

/// "jpeg qtables"

/// "jpeg dctables"

/// "jpeg actables"

/// "ycbcr coefficients"

/// "ycbcr subsampling"

/// "ycbcr positioning"

/// "ref black white"

/// "icc profile"

/// "gamma"

/// "icc profile descriptor"

/// "srgb renderingintent"

/// "image title"

/// "copyright"

/// "resolution x unit"

/// "resolution y unit"

/// "resolution x lengthunit"

/// "resolution y lengthunit"

/// "print flags"

/// "print flags version"

/// "print flags crop"

/// "print flags bleed width"

/// "print flags bleed width scale"

/// "halftone lpi"

/// "halftone lpiunit"

/// "halftone degree"

/// "halftone shape"

/// "halftone misc"

/// "halftone screen"

/// "jpeg quality"

/// "grid size"

/// "thumbnail format"

/// "thumbnail width"

/// "thumbnail height"

/// "thumbnail colordepth"

/// "thumbnail planes"

/// "thumbnail rawbytes"

/// "thumbnail size"

/// "thumbnail compressedsize"

/// "color transfer function"

/// "thumbnail data"

/// "thumbnail imagewidth"

/// "thumbnail imageheight"

/// "thumbnail bitspersample"

/// "thumbnail compression"

/// "thumbnail photometricinterp"

/// "thumbnail imagedescription"

/// "thumbnail equipmake"

/// "thumbnail equipmodel"

/// "thumbnail stripoffsets"

/// "thumbnail orientation"

/// "thumbnail samplesperpixel"

/// "thumbnail rowsperstrip"

/// "thumbnail stripbytescount"

/// "thumbnail resolutionx"

/// "thumbnail resolutiony"

/// "thumbnail planarconfig"

/// "thumbnail resolutionunit"

/// "thumbnail transferfunction"

/// "thumbnail softwareused"

/// "thumbnail datetime"

/// "thumbnail artist"

/// "thumbnail whitepoint"

/// "thumbnail primarychromaticities"

/// "thumbnail ycbcrcoefficients"

/// "thumbnail ycbcrsubsampling"

/// "thumbnail ycbcrpositioning"

/// "thumbnail refblackwhite"

/// "thumbnail copyright"

/// "luminance table"

/// "chrominance table"

/// "frame delay"

/// "loop count"

/// "pixel unit"

/// "pixel perunit x"

/// "pixel perunit y"

/// "palette histogram"

/// "exposure time"

/// "f-number"

/// "exposure prog"

/// "spectral sense"

/// "iso speed"

/// "oecf"

/// "ver"

/// "dtorig"

/// "dtdigitized"

/// "compconfig"

/// "compbpp"

/// "shutter speed"

/// "aperture"

/// "brightness"

/// "exposure bias"

/// "maxaperture"

/// "subjectdist"

/// "metering mode"

/// "lightsource"

/// "flash"

/// "focallength"

/// "maker note"

/// "user comment"

/// "dtsubsec"

/// "dtorigss"

/// "dtdigss"

/// "fpxver"

/// "colorspace"

/// "pixxdim"

/// "pixydim"

/// "relatedwav"

/// "interop"

/// "flashenergy"

/// "spatialfr"

/// "focalxres"

/// "focalyres"

/// "focalresunit"

/// "subject loc"

/// "exposure index"

/// "sensing method"

/// "filesource"

/// "scenetype"

/// "cfapattern"

/// "gps ver"

/// "gps latituderef"

/// "gps latitude"

/// "gps longituderef"

/// "gps longitude"

/// "gps altituderef"

/// "gps altitude"

/// "gps gpstime"

/// "gps gpssatellites"

/// "gps gpsstatus"

/// "gps gpsmeasuremode"

/// "gps gpsdop"

/// "gps speedref"

/// "gps speed"

/// "gps trackref"

/// "gps track"

/// "gps imgdirref"

/// "gps imgdir"

/// "gps mapdatum"

/// "gps destlatref"

/// "gps destlat"

/// "gps destlongref"

/// "gps destlong"

/// "gps destbearref"

/// "gps destbear"

/// "gps destdistref"

/// "gps destdist"

/// </summary>

public object this[string index]

{

get

{

return properties[index];

}

private System.Drawing.Bitmap bmp;

private string data;

private translation myhash;

private Hashtable properties;

internal int count

{

get

{

return this.properties.Count;

}

string sp;

/// <summary>

///

/// </summary>

/// <param name="id"></param>

/// <param name="len"></param>

/// <param name="type"></param>

/// <param name="data"></param>

public void settag(int id, string data)

{

Encoding ascii = Encoding.ASCII;

this.settag(id, data.Length, 0x2, ascii.GetBytes(data));

}

/// <summary>

///

/// </summary>

/// <param name="id"></param>

/// <param name="len"></param>

/// <param name="type"></param>

/// <param name="data"></param>

public void settag(int id, int len, short type, byte[] data)

{

PropertyItem p = createpropertyitem(type, id, len, data);

this.bmp.SetPropertyItem(p);

builddb(this.bmp.PropertyItems);

}

/// <summary>

///

/// </summary>

/// <param name="type"></param>

/// <param name="tag"></param>

/// <param name="len"></param>

/// <param name="value"></param>

/// <returns></returns>

private static PropertyItem createpropertyitem(short type, int tag, int len, byte[] value)

{

PropertyItem item;

// loads a propertyitem from a jpeg image stored in the assembly as a resource.

Assembly assembly = Assembly.GetExecutingAssembly();

Stream emptybitmapstream = assembly.GetManifestResourceStream("exifextractor.decoy.jpg");

System.Drawing.Image empty = System.Drawing.Image.FromStream(emptybitmapstream);

item = empty.PropertyItems[0];

// copies the data to the property item.

item.Type = type;

item.Len = len;

item.Id = tag;

item.Value = new byte[value.Length];

value.CopyTo(item.Value, 0);

return item;

}

/// <summary>

///

/// </summary>

/// <param name="bmp"></param>

/// <param name="sp"></param>

public exifextractor(ref System.Drawing.Bitmap bmp, string sp)

{

properties = new Hashtable();

this.bmp = bmp;

this.sp = sp;

myhash = new translation();

builddb(this.bmp.PropertyItems);

}

string msp = "";

public exifextractor(ref System.Drawing.Bitmap bmp, string sp, string msp)

{

properties = new Hashtable();

this.sp = sp;

this.msp = msp;

this.bmp = bmp;

myhash = new translation();

this.builddb(bmp.PropertyItems);

}

public static PropertyItem[] getexifproperties(string filename)

{

FileStream stream = new FileStream(filename, FileMode.Open, FileAccess.Read);

System.Drawing.Image image = System.Drawing.Image.FromStream(stream,

/* useembeddedcolormanagement = */ true,

/* validateimagedata = */ false);

return image.PropertyItems;

}

public exifextractor(string file, string sp, string msp)

{

properties = new Hashtable();

this.sp = sp;

this.msp = msp;

myhash = new translation();

this.builddb(getexifproperties(file));

}

/// <summary>

///

/// </summary>

private void builddb(System.Drawing.Imaging.PropertyItem[] parr)

{

properties.Clear();

data = "";

Encoding ascii = Encoding.ASCII;

foreach (System.Drawing.Imaging.PropertyItem p in parr)

{

string v = "";

string name = (string)myhash[p.Id];

// tag not found. skip it

if (name == null) continue;

data += name + ": ";

//1 = byte an 8-bit unsigned integer.,

if (p.Type == 0x1)

{

v = p.Value[0].ToString();

}

//2 = ascii an 8-bit byte containing one 7-bit ascii code. the final byte is terminated with null.,

else if (p.Type == 0x2)

{

// string

v = ascii.GetString(p.Value);

}

//3 = short a 16-bit (2 -byte) unsigned integer,

else if (p.Type == 0x3)

{

// orientation // lookup table

switch (p.Id)

{

case 0x8827: // iso

v = "iso-" + converttoint16u(p.Value).ToString();

break;

case 0xa217: // sensing method

{

switch (converttoint16u(p.Value))

{

case 1: v = "not defined"; break;

case 2: v = "one-chip color area sensor"; break;

case 3: v = "two-chip color area sensor"; break;

case 4: v = "three-chip color area sensor"; break;

case 5: v = "color sequential area sensor"; break;

case 7: v = "trilinear sensor"; break;

case 8: v = "color sequential linear sensor"; break;

default: v = " reserved"; break;

}

break;

case 0x8822: // aperture

switch (converttoint16u(p.Value))

{

case 0: v = "not defined"; break;

case 1: v = "manual"; break;

case 2: v = "normal program"; break;

case 3: v = "aperture priority"; break;

case 4: v = "shutter priority"; break;

case 5: v = "creative program (biased toward depth of field)"; break;

case 6: v = "action program (biased toward fast shutter speed)"; break;

case 7: v = "portrait mode (for closeup photos with the background out of focus)"; break;

case 8: v = "landscape mode (for landscape photos with the background in focus)"; break;

default: v = "reserved"; break;

}

break;

case 0x9207: // metering mode

switch (converttoint16u(p.Value))

{

case 0: v = "unknown"; break;

case 1: v = "average"; break;

case 2: v = "centerweightedaverage"; break;

case 3: v = "spot"; break;

case 4: v = "multispot"; break;

case 5: v = "pattern"; break;

case 6: v = "partial"; break;

case 255: v = "other"; break;

default: v = "reserved"; break;

}

break;

case 0x9208: // light source

{

switch (converttoint16u(p.Value))

{

case 0: v = "unknown"; break;

case 1: v = "daylight"; break;

case 2: v = "fluorescent"; break;

case 3: v = "tungsten"; break;

case 17: v = "standard light a"; break;

case 18: v = "standard light b"; break;

case 19: v = "standard light c"; break;

case 20: v = "d55"; break;

case 21: v = "d65"; break;

case 22: v = "d75"; break;

case 255: v = "other"; break;

default: v = "reserved"; break;

}

break;

case 0x9209:

{

switch (converttoint16u(p.Value))

{

case 0: v = "flash did not fire"; break;

case 1: v = "flash fired"; break;

case 5: v = "strobe return light not detected"; break;

case 7: v = "strobe return light detected"; break;

default: v = "reserved"; break;

}

break;

default:

v = converttoint16u(p.Value).ToString();

break;

}

//4 = long a 32-bit (4 -byte) unsigned integer,

else if (p.Type == 0x4)

{

// orientation // lookup table

v = converttoint32u(p.Value).ToString();

}

//5 = rational two longs. the first long is the numerator and the second long expresses the//denominator.,

else if (p.Type == 0x5)

{

// rational

byte[] n = new byte[p.Len / 2];

byte[] d = new byte[p.Len / 2];

Array.Copy(p.Value, 0, n, 0, p.Len / 2);

Array.Copy(p.Value, p.Len / 2, d, 0, p.Len / 2);

uint a = converttoint32u(n);

uint b = converttoint32u(d);

rational r = new rational(a, b);

//convert here

switch (p.Id)

{

case 0x9202: // aperture

v = "f/" + Math.Round(Math.Pow(Math.Sqrt(2), r.todouble()), 2).ToString();

break;

case 0x920a:

v = r.todouble().ToString();

break;

case 0x829a:

v = r.todouble().ToString();

break;

case 0x829d: // f-number

v = "f/" + r.todouble().ToString();

break;

default:

v = r.tostring("/");

break;

}

//7 = undefined an 8-bit byte that can take any value depending on the field definition,

else if (p.Type == 0x7)

{

switch (p.Id)

{

case 0xa300:

{

if (p.Value[0] == 3)

{

v = "dsc";

}

else

{

v = "reserved";

}

break;

}

case 0xa301:

if (p.Value[0] == 1)

v = "a directly photographed image";

else

v = "not a directly photographed image";

break;

default:

v = "-";

break;

}

//9 = slong a 32-bit (4 -byte) signed integer (2s complement notation),

else if (p.Type == 0x9)

{

v = converttoint32(p.Value).ToString();

}

//10 = srational two slongs. the first slong is the numerator and the second slong is the

//denominator.

else if (p.Type == 0xa)

{

// rational

byte[] n = new byte[p.Len / 2];

byte[] d = new byte[p.Len / 2];

Array.Copy(p.Value, 0, n, 0, p.Len / 2);

Array.Copy(p.Value, p.Len / 2, d, 0, p.Len / 2);

int a = converttoint32(n);

int b = converttoint32(d);

rational r = new rational(a, b);

// convert here

switch (p.Id)

{

case 0x9201: // shutter speed

v = "1/" + Math.Round(Math.Pow(2, r.todouble()), 2).ToString();

break;

case 0x9203:

v = Math.Round(r.todouble(), 4).ToString();

break;

default:

v = r.tostring("/");

break;

}

// add it to the list

if (properties[name] == null)

properties.Add(name, v);

// cat it too

data += v;

data += this.sp;

}

/// <summary>

///

/// </summary>

/// <returns></returns>

public override string ToString()

{

return data;

}

/// <summary>

///

/// </summary>

/// <param name="arr"></param>

/// <returns></returns>

int converttoint32(byte[] arr)

{

if (arr.Length != 4)

return 0;

else

return arr[3] << 24 | arr[2] << 16 | arr[1] << 8 | arr[0];

}

/// <summary>

///

/// </summary>

/// <param name="arr"></param>

/// <returns></returns>

int converttoint16(byte[] arr)

{

if (arr.Length != 2)

return 0;

else

return arr[1] << 8 | arr[0];

}

/// <summary>

///

/// </summary>

/// <param name="arr"></param>

/// <returns></returns>

uint converttoint32u(byte[] arr)

{

if (arr.Length != 4)

return 0;

else

return Convert.ToUInt32(arr[3] << 24 | arr[2] << 16 | arr[1] << 8 | arr[0]);

}

/// <summary>

///

/// </summary>

/// <param name="arr"></param>

/// <returns></returns>

uint converttoint16u(byte[] arr)

{

if (arr.Length != 2)

return 0;

else

return Convert.ToUInt16(arr[1] << 8 | arr[0]);

}

#region ienumerable members

public IEnumerator GetEnumerator()

{

// todo: add exifextractor.getenumerator implementation

return (new exifextractorenumerator(this.properties));

}

#endregion

}

// dont touch this class. its for ienumerator

class exifextractorenumerator : IEnumerator

{

Hashtable exiftable;

IDictionaryEnumerator index;

internal exifextractorenumerator(Hashtable exif)

{

this.exiftable = exif;

this.Reset();

index = exif.GetEnumerator();

}

#region ienumerator members

public void Reset()

{

this.index = null;

}

public object Current

{

get

{

return (new pair(this.index.Key, this.index.Value));

}

public bool MoveNext()

{

if (index != null && index.MoveNext())

return true;

else

return false;

}

#endregion

}

public class pair

{

public string first;

public string second;

public pair(object key, object value)

{

this.first = key.ToString();

this.second = value.ToString();

}