PageRenderTime 93ms CodeModel.GetById 19ms RepoModel.GetById 1ms app.codeStats 0ms

/wp-content/plugins/yet-another-photoblog/lib/phpExifRW-1.1/exifReader.inc

https://github.com/Mercedes/ratonesytortillas
PHP | 1718 lines | 1125 code | 197 blank | 396 comment | 152 complexity | 72dd73ae670ce088e5e13285ea3133dd MD5 | raw file

Large files files are truncated, but you can click here to view the full file

    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * PHP Class to read EXIF information
    4. 

  4.  * that most of the digital camera produce
    5. 

  5.  *
    6. 

  6.  * This class is based on jhead (in C) by Matthias Wandel
    7. 

  7.  *
    8. 

  8.  * Vinay Yadav (vinay@vinayras.com)
    9. 

  9.  * http://open.vinayras.com/phpexifrw_exif_reader_writer
    10. 

  10.  *
    11. 

  11.  * For more information on EXIF
    12. 

  12.  * http://www.exif.org/
    13. 

  13.  *
    14. 

  14.  * Features:
    15. 

  15.  *   - Read Exif Information
    16. 

  16.  *   - Extract and display emdedded thumbnails
    17. 

  17.  *
    18. 

  18.  *  Tested With
    19. 

    20. 

  20.         - Sony
    21. 

  21.             - Cybershot (Sony)
    22. 

  22.             - DSC-D700
    23. 

  23.             - PowerShotA5
    24. 

  24. 			- Sony P71
    25. 

  25.         - SANYO Electric Co.,Ltd
    26. 

  26.             - SR6
    27. 

  27.             - SX113
    28. 

  28.         - OLYMPUS OPTICAL CO.,LTD
    29. 

  29.             - C960Z, D460Z
    30. 

  30. 			- C3000Z
    31. 

  31.         - Canon
    32. 

  32.             PowerShot A40 (Canon)
    33. 

  33.             Canon DIGITAL IXUS
    34. 

  34. 			Canon 300D
    35. 

  35.         - RICOH
    36. 

  36.             - Caplio RR30
    37. 

  37.             - RDC-5300
    38. 

  38.         - NIKON
    39. 

  39.             - D100 (NIKON CORPORATION)
    40. 

  40.             - E5700 (NIKON)
    41. 

  41.             - E950
    42. 

  42.         - CASIO QV-8000SX
    43. 

  43.         - KODAK
    44. 

  44.             - DC290 Zoom Digital Camera (V01.00) [Eastman Kodak Company]
    45. 

  45.             - DC210 Zoom (V05.00) [Eastman Kodak Company]
    46. 

  46.             - KODAK DC240 ZOOM DIGITAL CAMERA
    47. 

  47.         - FujiFilm
    48. 

  48.             DX10
    49. 

  49.             FinePix40i
    50. 

  50.             MX-1700ZOOM
    51. 

  51.  *
    52. 

  52.  *
    53. 

  53.  */
    54. 

  54. 

  55. /** * Start Of Frame N */
    56. 

  56. define("M_SOF0",0xC0);
    57. 

  57. /** * N indicates which compression process */
    58. 

  58. define("M_SOF1",0xC1);
    59. 

  59. /** * Only SOF0-SOF2 are now in common use */
    60. 

  60. define("M_SOF2",0xC2);
    61. 

  61. /** *  */
    62. 

  62. define("M_SOF3",0xC3);
    63. 

  63. /** * NB: codes C4 and CC are NOT SOF markers */
    64. 

  64. define("M_SOF5",0xC5);
    65. 

  65. /** *  */
    66. 

  66. define("M_SOF6",0xC6);
    67. 

  67. /** *  */
    68. 

  68. define("M_SOF7",0xC7);
    69. 

  69. /** *  */
    70. 

  70. define("M_SOF9",0xC9);
    71. 

  71. /** *  */
    72. 

  72. define("M_SOF10",0xCA);
    73. 

  73. /** *  */
    74. 

  74. define("M_SOF11",0xCB);
    75. 

  75. /** *  */
    76. 

  76. define("M_SOF13",0xCD);
    77. 

  77. /** *  */
    78. 

  78. define("M_SOF14",0xCE);
    79. 

  79. /** *  */
    80. 

  80. define("M_SOF15",0xCF);
    81. 

  81. /** * Start Of Image (beginning of datastream) */
    82. 

  82. define("M_SOI",0xD8);
    83. 

  83. /** * End Of Image (end of datastream) */
    84. 

  84. define("M_EOI",0xD9);
    85. 

  85. /** * Start Of Scan (begins compressed data) */
    86. 

  86. define("M_SOS",0xDA);
    87. 

  87. /** * Jfif marker */
    88. 

  88. define("M_JFIF",0xE0);
    89. 

  89. /** * Exif marker */
    90. 

  90. define("M_EXIF",0xE1);
    91. 

  91. 

  92. define("M_EXIF_EXT",0xE2); // 226 - Exif Extended Data
    93. 

  93. define("M_QUANTA",0xDB); // 219 - Quantisation Table Definition
    94. 

  94. define("M_HUFF",0xC4); // (DEC=196) - Huffman Table Definition
    95. 

  95. /** * Image Title -- */
    96. 

  96. define("M_COM",0xFE);
    97. 

  97. 

  98. define("NUM_FORMATS","12");
    99. 

  99. 

  100. /** * Tag Data Format */
    101. 

  101. define("FMT_BYTE","1");
    102. 

  102. /** * ASCII */
    103. 

  103. define("FMT_STRING","2");
    104. 

  104. /** * Short */
    105. 

  105. define("FMT_USHORT","3");
    106. 

  106. /** * Long */
    107. 

  107. define("FMT_ULONG","4");
    108. 

  108. /** * Rational */
    109. 

  109. define("FMT_URATIONAL","5");
    110. 

  110. /** * Byte */
    111. 

  111. define("FMT_SBYTE","6");
    112. 

  112. /** * Undefined */
    113. 

  113. define("FMT_UNDEFINED","7");
    114. 

  114. /** * Short */
    115. 

  115. define("FMT_SSHORT","8");
    116. 

  116. /** * Long */
    117. 

  117. define("FMT_SLONG","9");
    118. 

  118. /** * Rational */
    119. 

  119. define("FMT_SRATIONAL","10");
    120. 

  120. /** * Single */
    121. 

  121. define("FMT_SINGLE","11");
    122. 

  122. /** * Double */
    123. 

  123. define("FMT_DOUBLE","12");
    124. 

  124. 

  125. /** * Exif IFD */
    126. 

  126. define("TAG_EXIF_OFFSET","0x8769");
    127. 

  127. /** * Interoperability tag */
    128. 

  128. define("TAG_INTEROP_OFFSET","0xa005");
    129. 

  129. /** * Image input equipment manufacturer */
    130. 

  130. define("TAG_MAKE","0x010F");
    131. 

  131. /** * Image input equipment model */
    132. 

  132. define("TAG_MODEL","0x0110");
    133. 

  133. /** * Orientation of image */
    134. 

  134. define("TAG_ORIENTATION","0x0112");
    135. 

  135. /** * Exposure Time */
    136. 

  136. define("TAG_EXPOSURETIME","0x829A");
    137. 

  137. /** * F Number */
    138. 

  138. define("TAG_FNUMBER","0x829D");
    139. 

  139. /** * Shutter Speed */
    140. 

  140. define("TAG_SHUTTERSPEED","0x9201");
    141. 

  141. /** * Aperture */
    142. 

  142. define("TAG_APERTURE","0x9202");
    143. 

  143. /** * Aperture */
    144. 

  144. define("TAG_MAXAPERTURE","0x9205");
    145. 

  145. /** * Lens Focal Length */
    146. 

  146. define("TAG_FOCALLENGTH","0x920A");
    147. 

  147. /** * The date and time when the original image data was generated. */
    148. 

  148. define("TAG_DATETIME_ORIGINAL","0x9003");
    149. 

  149. /** * User Comments */
    150. 

  150. define("TAG_USERCOMMENT","0x9286");
    151. 

  151. /** * subject Location */
    152. 

  152. define("TAG_SUBJECT_DISTANCE","0x9206");
    153. 

  153. /** * Flash */
    154. 

  154. define("TAG_FLASH","0x9209");
    155. 

  155. /** * Focal Plane X Resolution */
    156. 

  156. define("TAG_FOCALPLANEXRES","0xa20E");
    157. 

  157. /** * Focal Plane Resolution Units */
    158. 

  158. define("TAG_FOCALPLANEUNITS","0xa210");
    159. 

  159. /** * Image Width */
    160. 

  160. define("TAG_EXIF_IMAGEWIDTH","0xA002");
    161. 

  161. /** * Image Height */
    162. 

  162. define("TAG_EXIF_IMAGELENGTH","0xA003");
    163. 

  163. /** * Exposure Bias */
    164. 

  164. define("TAG_EXPOSURE_BIAS","0x9204");
    165. 

  165. /** * Light Source */
    166. 

  166. define("TAG_WHITEBALANCE","0x9208");
    167. 

  167. /** * Metering Mode */
    168. 

  168. define("TAG_METERING_MODE","0x9207");
    169. 

  169. /** * Exposure Program */
    170. 

  170. define("TAG_EXPOSURE_PROGRAM","0x8822");
    171. 

  171. /** * ISO Equivalent Speed Rating */
    172. 

  172. define("TAG_ISO_EQUIVALENT","0x8827");
    173. 

  173. /** * Compressed Bits Per Pixel */
    174. 

  174. define("TAG_COMPRESSION_LEVEL","0x9102");
    175. 

  175. /** * Thumbnail Start Offset */
    176. 

  176. define("TAG_THUMBNAIL_OFFSET","0x0201");
    177. 

  177. /** * Thumbnail Length */
    178. 

  178. define("TAG_THUMBNAIL_LENGTH","0x0202");
    179. 

  179. /** * Image Marker */
    180. 

  180. define("PSEUDO_IMAGE_MARKER",0x123);
    181. 

  181. /** * Max Image Title Length */
    182. 

  182. define("MAX_COMMENT",2000);
    183. 

  183. 

  184. define("TAG_ARTIST","0x013B");
    185. 

  185. define("TAG_COPYRIGHT","0x8298");
    186. 

  186. 

  187. //--------------------------------
    188. 

  188. 

  189. define("TAG_IMAGE_WD","0x0100"); // image width
    190. 

  190. define("TAG_IMAGE_HT","0x0101"); // image height
    191. 

  191. define("TAG_IMAGE_BPS","0x0102"); // Bits Per sample
    192. 

  192. 

  193. define("TAG_IMAGE_PHOTO_INT","0x0106"); // photometricinterpretation
    194. 

  194. define("TAG_IMAGE_SOFFSET","0x0111"); // stripoffsets
    195. 

  195. 

  196. define("TAG_IMAGE_SPP","0x0115"); // Samples per pixel - 277
    197. 

  197. define("TAG_IMAGE_RPS","0x0116"); // RowsPerStrip - 278
    198. 

  198. define("TAG_IMAGE_SBC","0x0117"); // StripByteCounts - 279
    199. 

  199. 

  200. define("TAG_IMAGE_P_CONFIG","0x011C"); // Planar Configuration - 284
    201. 

  201. 

  202. define("TAG_IMAGE_DESC","0x010E"); // image title
    203. 

  203. define("TAG_X_RESOLUTION","0x011A"); // Image resolution in width direction
    204. 

  204. define("TAG_Y_RESOLUTION","0x011B"); // Image resolution in height direction
    205. 

  205. define("TAG_RESOLUTION_UNIT","0x0128"); // Unit of X and Y resolution
    206. 

  206. define("TAG_SOFTWARE","0x0131"); // Software used
    207. 

  207. define("TAG_FILE_MODDATE","0x0132"); // DateTime File change date and time
    208. 

  208. define("TAG_YCBCR_POSITIONING","0x0213"); // Y and C positioning
    209. 

  209. define("TAG_EXIF_VERSION","0x9000"); // Exif version
    210. 

  210. define("TAG_DATE_TIME_DIGITIZED","0x9004"); // Date and time of digital data
    211. 

  211. define("TAG_COMPONENT_CONFIG","0x9101"); // Component configuration
    212. 

  212. define("TAG_MAKER_NOTE","0x927C");
    213. 

  213. define("TAG_SUB_SEC_TIME","0x9290");
    214. 

  214. define("TAG_SUB_SEC_TIME_ORIG","0x9291");
    215. 

  215. define("TAG_SUB_SEC_TIME_DIGITIZED","0x9292");
    216. 

  216. define("TAG_FLASHPIX_VER","0xA000"); //FlashPixVersion
    217. 

  217. define("TAG_COLOR_SPACE","0xA001"); //ColorSpace
    218. 

  218. define("TAG_RELATED_SOUND_FILE","0xA004"); //Related audio file
    219. 

  219. 

  220. define("TAG_GPS_IFD" , "0x8825"); // GPS IFD
    221. 

  221. 

  222. define("TAG_GPS_LATITUDE_REF","0x0001"); //
    223. 

  223. define("TAG_GPS_LATITUDE","0x0002"); //
    224. 

  224. 

  225. define("TAG_GPS_LONGITUDE_REF","0x0003"); //
    226. 

  226. define("TAG_GPS_LONGITUDE","0x0004"); //
    227. 

  227. 

  228. define("TAG_GPS_TrackRef","0x000E"); //
    229. 

  229. define("TAG_GPS_GPSTrack","0x000F"); //
    230. 

  230. define("TAG_GPS_GPSImgDirectionRef","0x0010"); //
    231. 

  231. define("TAG_GPS_GPSImgDirection","0x0011"); //
    232. 

  232. define("TAG_GPS_GPSMapDatum","0x0012"); //
    233. 

  233. define("TAG_GPS_GPSDestLatitudeRef","0x0013"); //
    234. 

  234. define("TAG_GPS_GPSDestLatitude","0x0014"); //
    235. 

  235. define("TAG_GPS_GPSDestLongitudeRef","0x0015"); //
    236. 

  236. define("TAG_GPS_GPSDestLongitude","0x0016"); //
    237. 

  237. define("TAG_GPS_GPSDestBearingRef","0x0017"); //
    238. 

  238. define("TAG_GPS_GPSDestBearing","0x0018"); //
    239. 

  239. define("TAG_GPS_GPSDestDistanceRef","0x0019"); //
    240. 

  240. define("TAG_GPS_GPSDestDistance","0x001A"); //
    241. 

  241. define("TAG_GPS_GPSProcessingMethod","0x001B"); //
    242. 

  242. define("TAG_GPS_GPSAreaInformation","0x001C"); //
    243. 

  243. define("TAG_GPS_GPSDateStamp","0x001D"); //
    244. 

  244. define("TAG_GPS_GPSDifferential","0x001E"); //
    245. 

  245. 

  246. define("TAG_AUDIO_IMA_ADPCM_DESC","0x0028"); //  IMA-ADPCM Audio File Description Example - 40
    247. 

  247. define("TAG_AUDIO_MU_LAW_DESC","0x0032"); //  µ-Law Audio File Description Sample - 50
    248. 

  248. 

  249. define("TAG_AUDIO_MU_LAW","0x0086"); // (This File µ-LAW Sample) - 134
    250. 

  250. 

  251. 

  252. define("TAG_EXPOSURE_INDEX","0xA215"); // Exposure index
    253. 

  253. 

  254. define("TAG_SENSING_METHOD","0xA217"); // SensingMethod
    255. 

  255. 

  256. define("TAG_SOUCE_TYPE","0xA300"); // FileSource
    257. 

  257. define("TAG_SCENE_TYPE","0xA301"); // SceneType
    258. 

  258. 

  259. define("TAG_CFA_PATTERN","0xA302"); // CFA Pattern
    260. 

  260. 

  261. /** Tags in EXIF 2.2 Only */
    262. 

  262. define("TAG_COMPRESS_SCHEME","0x0103"); //
    263. 

  263. define("TAG_CUSTOM_RENDERED","0xA401"); //  CustomRendered
    264. 

  264. define("TAG_EXPOSURE_MODE","0xA402"); // Exposure mode      ExposureMode
    265. 

  265. define("TAG_WHITE_BALANCE","0xA403"); // White balance      WhiteBalance
    266. 

  266. define("TAG_DIGITAL_ZOOM_RATIO","0xA404"); // Digital zoom ratio      DigitalZoomRatio
    267. 

  267. define("TAG_FLENGTH_IN35MM","0xA405"); // Focal length in 35 mm film      FocalLengthIn35mmFilm
    268. 

  268. define("TAG_SCREEN_CAP_TYPE","0xA406"); // Scene capture type      SceneCaptureType
    269. 

  269. define("TAG_GAIN_CONTROL","0xA407"); //Gain control
    270. 

  270. define("TAG_CONTRAST","0xA408"); // Contrast
    271. 

  271. define("TAG_SATURATION","0xA409"); // Saturation
    272. 

  272. define("TAG_SHARPNESS","0xA40A"); // Sharpness
    273. 

  273. define("TAG_DEVICE_SETTING_DESC","0xA40B"); // SDevice settings description      DeviceSettingDescription
    274. 

  274. define("TAG_DIST_RANGE","0xA40C"); //Subject distance range SubjectDistanceRange
    275. 

  275. 

  276. define("TAG_FOCALPLANE_YRESOL","0xA20F");; //FocalPlaneYResolution
    277. 

  277. define("TAG_BRIGHTNESS","0x9203");; //Brightness
    278. 

  278. //--------------------------------
    279. 

  279. /** error Description  */
    280. 

  280. /**
    281. 

  281.   1 - File does not exists!
    282. 

  282.   2 -
    283. 

  283.   3 - Filename not provided
    284. 

    285. 

  285.   10 - too many padding bytes
    286. 

  286.   11 - "invalid marker"
    287. 

  287.   12 - Premature end of file?
    288. 

    289. 

    290. 

  290.   51 - "Illegal subdirectory link"
    291. 

  291.   52 - "NOT EXIF FORMAT"
    292. 

  292.   53 - "Invalid Exif alignment marker.\n"
    293. 

  293.   54 - "Invalid Exif start (1)"
    294. 

    295. 

  295. */
    296. 

  296. 

  297. 

  298. /**
    299. 

  299.  * PHP Class to read, write and transfer EXIF information
    300. 

  300.  * that most of the digital camera produces
    301. 

  301.  * Currenty it can only read JPEG file.
    302. 

  302.  */
    303. 

  303.  /**
    304. 

  304.  * @author Vinay Yadav (vinayRas) < vinay@sanisoft.com >
    305. 

  305.  *
    306. 

  306.  * @todo Writing exif information to the file.
    307. 

  307.  * @todo Add EXIF audio reading methods (I think it exists!)
    308. 

  308.  * @todo Support of additional tags.
    309. 

  309.  * @todo Handling Unicode character in UserComment tag of EXif Information.
    310. 

  310.  *
    311. 

  311.  * @version 0.5
    312. 

  312.  * @licence http://opensource.org/licenses/lgpl-license.php GNU LGPL
    313. 

  313.  */
    314. 

  314. class phpExifReader {
    315. 

  315. 

  316.     /***
    317. 

  317.     * Array containg all Exif and JPEG image attributes
    318. 

  318.     * into regular expressions for themselves.
    319. 

  319.     * $ImageInfo[TAG] = TAG_VALUE;
    320. 

  320.     *
    321. 

  321.     * @var       array
    322. 

  322.     * @access    private
    323. 

  323.     *
    324. 

  324.     */
    325. 

  325.     var $ImageInfo = array();
    326. 

  326. 

  327.     var $MotorolaOrder = 0;
    328. 

  328.     var $ExifImageWidth = 0; //
    329. 

  329.     var $FocalplaneXRes = 0; //
    330. 

  330.     var $FocalplaneUnits = 0; //
    331. 

  331.     var $sections = array();
    332. 

  332.     var $currSection = 0;  /** Stores total number fo Sections */
    333. 

  333. 

  334.     var $BytesPerFormat = array(0,1,1,2,4,8,1,1,2,4,8,4,8);
    335. 

  335. 

  336.     var $ReadMode = array(
    337. 

  337.                             "READ_EXIF" => 1,
    338. 

  338.                             "READ_IMAGE" => 2,
    339. 

  339.                             "READ_ALL" => 3
    340. 

  340.                         );
    341. 

  341. 

  342.     var $ImageReadMode = 3; /** related to $RealMode arrays values */
    343. 

  343.     var $file =  "";     /** JPEG file to parse for EXIF data */
    344. 

  344.     var $newFile = 1;   /** flag to check if the current file has been parsed or not. */
    345. 

  345. 

  346.     var $thumbnail = ""; /* Name of thumbnail */
    347. 

  347.     var $thumbnailURL = ""; /* */
    348. 

  348. 

  349.     var $exifSection = -1;   // market the exif section index oout of all sections
    350. 

  350. 

  351.     var $errno = 0;
    352. 

  352.     var $errstr = "";
    353. 

  353. 

  354.     var $debug = false;
    355. 

  355. 

  356.     // Caching ralated variables
    357. 

  357.     var $caching = false; /* Should cacheing of image thumnails be allowed? */
    358. 

  358.     var $cacheDir = ""; /* Checkout constructor for default path. */
    359. 

  359. 

  360.     /**
    361. 

  361.      * Constructor
    362. 

  362.      * @param string File name to be parsed.
    363. 

  363.      *
    364. 

  364.      */
    365. 

  365.     function phpExifReader($file = "") {
    366. 

  366.       $this->timeStart = $this->getmicrotime();
    367. 

  367.       if(!empty($file)) {
    368. 

  368.         $this->file = $file;
    369. 

  369.       }
    370. 

  370. 

  371.       /**
    372. 

  372.       * Initialize some variables. Avoid lots of errors with fulll error_reporting
    373. 

  373.       */
    374. 

  374.       $this->ExifImageLength       = 0;
    375. 

  375.       $this->ImageInfo['h']["resolutionUnit"] = 0;
    376. 

  376. 

  377.       $this->ImageInfo[TAG_MAXAPERTURE] = 0;
    378. 

  378.       $this->ImageInfo[TAG_ISO_EQUIVALENT] = 0;
    379. 

  379.       $this->ImageInfo[TAG_ORIENTATION] = 0;
    380. 

  380. 

  381.       $this->ThumbnailSize = 0;
    382. 

  382. 

  383.       if($this->caching) {
    384. 

  384.         $this->cacheDir = dirname(__FILE__)."/.cache_thumbs";
    385. 

  385. 

  386.         /**
    387. 

  387.         * If Cache directory does not exists then attempt to create it.
    388. 

  388.         */
    389. 

  389.         if(!is_dir($this->cacheDir)) {
    390. 

  390.              mkdir($this->cacheDir);
    391. 

  391.         }
    392. 

  392. 

  393.           // Prepare the ame of thumbnail
    394. 

  394.           if(is_dir($this->cacheDir)) {
    395. 

  395.             $this->thumbnail = $this->cacheDir."/".basename($this->file);
    396. 

  396.             $this->thumbnailURL = ".cache_thumbs/".basename($this->file);
    397. 

  397.           }
    398. 

  398.       }
    399. 

  399. 

  400.       /** check if file exists! */
    401. 

  401.       if(!file_exists($this->file)) {
    402. 

  402.          $this->errno = 1;
    403. 

  403.          $this->errstr = "File '".$this->file."' does not exists!";
    404. 

  404.       }
    405. 

  405.       $this->currSection = 0;
    406. 

  406. 

  407.       $this->processFile();
    408. 

  408.     }
    409. 

  409. 

  410.     /**
    411. 

  411.      * Show Debugging information
    412. 

  412.      *
    413. 

  413.      * @param   string     Debugging message to display
    414. 

  414.      * @param   int   Type of error (0 - Warning, 1 - Error)
    415. 

  415.      * @return    void
    416. 

  416.      *
    417. 

  417.      */
    418. 

  418.     function debug($str,$TYPE = 0,$file="",$line=0) {
    419. 

  419.        if($this->debug) {
    420. 

  420.         echo "<br>[$file:$line:".($this->getDiffTime())."]$str";
    421. 

  421.         flush();
    422. 

  422.         if($TYPE == 1) {
    423. 

  423.            exit;
    424. 

  424.         }
    425. 

  425.        }
    426. 

  426.     }
    427. 

  427. 

  428.     /**
    429. 

  429.      * Processes the whole file.
    430. 

  430.      *
    431. 

  431.      */
    432. 

  432.     function processFile() {
    433. 

  433.         /** dont reparse the whole file. */
    434. 

  434.         if(!$this->newFile) return true;
    435. 

  435.         
    436. 

  436.         if(!file_exists($this->file)) {
    437. 

  437.             echo "<br>Error: File ".($this->file)."does not exists!";
    438. 

  438.             exit;
    439. 

  439.         }
    440. 

  440. 

  441.         $this->debug("Stating Processing of ".$this->newFile,0,__FILE__,__LINE__);
    442. 

  442. 

  443.         $i = 0; $exitAll = 0;
    444. 

  444.         /** Open the JPEG in binary safe reading mode */
    445. 

  445.         $fp = fopen($this->file,"rb");
    446. 

  446. 

  447.         $this->ImageInfo["h"]["FileName"] = $this->file;
    448. 

  448.         $this->ImageInfo["h"]["FileSize"] = filesize($this->file); /** Size of the File */
    449. 

  449.         $this->ImageInfo["h"]["FileDateTime"] = filectime($this->file); /** File node change time */
    450. 

  450. 

  451.         /** check whether jped image or not */
    452. 

  452.         $a = fgetc($fp);
    453. 

  453.         if (ord($a) != 0xff || ord(fgetc($fp)) != M_SOI){
    454. 

  454.                 $this->debug("Not a JPEG FILE",1);
    455. 

  455.                 $this->errorno = 1;
    456. 

  456.                 $this->errorstr = "File '".$this->file."' is not a JPEG File!";
    457. 

  457.         }
    458. 

  458.         $tmpTestLevel = 0;
    459. 

  459.         /** Examines each byte one-by-one */
    460. 

  460.         while(!feof($fp)) {
    461. 

  461.             $data = array();
    462. 

  462.                 for ($a=0;$a<7;$a++){
    463. 

  463.                         $marker = fgetc($fp);
    464. 

  464.                         if (ord($marker) != 0xff) break;
    465. 

  465.                         if ($a >= 6){
    466. 

  466.                                 $this->errno = 10;
    467. 

  467.                                 $this->errstr = "too many padding bytes!";
    468. 

  468.                                 $this->debug($this->errstr,1);
    469. 

  469.                                 return false;
    470. 

  470.                         }
    471. 

  471.                 }
    472. 

  472. 

  473.                 if (ord($marker) == 0xff){
    474. 

  474.                     // 0xff is legal padding, but if we get that many, something's wrong.
    475. 

  475.                     $this->errno = 10;
    476. 

  476.                     $this->errstr = "too many padding bytes!";
    477. 

  477.                     $this->debug($this->errstr,1);
    478. 

  478.                 }
    479. 

  479. 

  480.         $marker = ord($marker);
    481. 

  481.         $this->sections[$this->currSection]["type"] = $marker;
    482. 

  482. 

  483.         // Read the length of the section.
    484. 

  484.         $lh = ord(fgetc($fp));
    485. 

  485.         $ll = ord(fgetc($fp));
    486. 

  486. 

  487.         $itemlen = ($lh << 8) | $ll;
    488. 

  488. 

  489.         if ($itemlen < 2){
    490. 

  490.                 $this->errno = 11;
    491. 

  491.                 $this->errstr = "invalid marker";
    492. 

  492.                 $this->debug($this->errstr,1);
    493. 

  493.         }
    494. 

  494.         $this->sections[$this->currSection]["size"] = $itemlen;
    495. 

  495. 

  496.         $tmpDataArr = array();  /** Temporary Array */
    497. 

  497. 

  498.         $tmpStr = fread($fp,$itemlen-2);
    499. 

  499.         /*
    500. 

  500.         $tmpDataArr[] = chr($lh);
    501. 

  501.         $tmpDataArr[] = chr($ll);
    502. 

    503. 

  503.         $chars = preg_split('//', $tmpStr, -1, PREG_SPLIT_NO_EMPTY);
    504. 

  504.         $tmpDataArr = array_merge($tmpDataArr,$chars);
    505. 

    506. 

  506.         $data = $tmpDataArr;
    507. 

  507.         */
    508. 

  508.         $data = chr($lh).chr($ll).$tmpStr;
    509. 

  509. 

  510.         //$this->sections[$this->currSection]["data"] = $data;
    511. 

  511. 

  512.         $this->debug("<hr><h1>".$this->currSection.":</h1>");
    513. 

  513.         //print_r($data);
    514. 

  514.         $this->debug("<hr>");
    515. 

  515. 

  516.         //if(count($data) != $itemlen) {
    517. 

  517.         if(strlen($data) != $itemlen) {
    518. 

  518.             $this->errno = 12;
    519. 

  519.             $this->errstr = "Premature end of file?";
    520. 

  520.             $this->debug($this->errstr,1);
    521. 

  521.         }
    522. 

  522. 

  523.         $this->currSection++; /** */
    524. 

  524. 

  525.         switch($marker) {
    526. 

  526.                 case M_SOS:
    527. 

  527.                     $this->debug("<br>Found '".M_SOS."' Section, Prcessing it... <br>");;
    528. 

  528.                         // If reading entire image is requested, read the rest of the data.
    529. 

  529.                         if ($this->ImageReadMode & $this->ReadMode["READ_IMAGE"]){
    530. 

  530.                         // Determine how much file is left.
    531. 

  531.                                 $cp = ftell($fp);
    532. 

  532.                                 fseek($fp,0, SEEK_END);
    533. 

  533.                                 $ep = ftell($fp);
    534. 

  534.                                 fseek($fp, $cp, SEEK_SET);
    535. 

  535. 

  536.                         $size = $ep-$cp;
    537. 

  537.                         $got = fread($fp, $size);
    538. 

  538. 

  539.                         $this->sections[$this->currSection]["data"] = $got;
    540. 

  540.                         $this->sections[$this->currSection]["size"] = $size;
    541. 

  541.                         $this->sections[$this->currSection]["type"] = PSEUDO_IMAGE_MARKER;
    542. 

  542.                         $this->currSection++;
    543. 

  543.                         $HaveAll = 1;
    544. 

  544.                         $exitAll =1;
    545. 

  545.                         }
    546. 

  546.                         $this->debug("<br>'".M_SOS."' Section, PROCESSED<br>");
    547. 

  547.                     break;
    548. 

  548.                 case M_COM: // Comment section
    549. 

  549.                         $this->debug("<br>Found '".M_COM."'(Comment) Section, Processing<br>");
    550. 

  550.                         $this->process_COM($data, $itemlen);
    551. 

  551.                         $this->debug("<br>'".M_COM."'(Comment) Section, PROCESSED<br>");
    552. 

  552. 

  553.                         $tmpTestLevel++;
    554. 

  554.                     break;
    555. 

  555.                 case M_SOI:
    556. 

  556.                         $this->debug(" <br> === START OF IMAGE =====<br>");
    557. 

  557.                 break;
    558. 

  558.                 case M_EOI:
    559. 

  559.                         $this->debug(" <br>=== END OF IMAGE =====<br> ");
    560. 

  560.                 break;
    561. 

  561.                 case M_JFIF:
    562. 

  562.                         // Regular jpegs always have this tag, exif images have the exif
    563. 

  563.                         // marker instead, althogh ACDsee will write images with both markers.
    564. 

  564.                         // this program will re-create this marker on absence of exif marker.
    565. 

  565.                         // hence no need to keep the copy from the file.
    566. 

  566.                         //echo " <br> === M_JFIF =====<br>";
    567. 

  567.                         $this->sections[--$this->currSection]["data"] = "";
    568. 

  568.                         break;
    569. 

  569.                 case M_EXIF:
    570. 

  570.                         // Seen files from some 'U-lead' software with Vivitar scanner
    571. 

  571.                         // that uses marker 31 for non exif stuff.  Thus make sure
    572. 

  572.                         // it says 'Exif' in the section before treating it as exif.
    573. 

  573.                         $this->debug("<br>Found '".M_EXIF."'(Exif) Section, Proccessing<br>");
    574. 

  574.                         $this->exifSection = $this->currSection-1;
    575. 

  575.                         if (($this->ImageReadMode & $this->ReadMode["READ_EXIF"]) && ($data[2].$data[3].$data[4].$data[5]) == "Exif"){
    576. 

  576.                                 $this->process_EXIF($data, $itemlen);
    577. 

  577.                         }else{
    578. 

  578.                                 // Discard this section.
    579. 

  579.                                 $this->sections[--$this->currSection]["data"] = "";
    580. 

  580.                         }
    581. 

  581.                         $this->debug("<br>'".M_EXIF."'(Exif) Section, PROCESSED<br>");
    582. 

  582.                         $tmpTestLevel++;
    583. 

  583.                 break;
    584. 

  584.                 case M_SOF0:
    585. 

  585.                 case M_SOF1:
    586. 

  586.                 case M_SOF2:
    587. 

  587.                 case M_SOF3:
    588. 

  588.                 case M_SOF5:
    589. 

  589.                 case M_SOF6:
    590. 

  590.                 case M_SOF7:
    591. 

  591.                 case M_SOF9:
    592. 

  592.                 case M_SOF10:
    593. 

  593.                 case M_SOF11:
    594. 

  594.                 case M_SOF13:
    595. 

  595.                 case M_SOF14:
    596. 

  596.                 case M_SOF15:
    597. 

  597.                         $this->debug("<br>Found M_SOFn Section, Processing<br>");
    598. 

  598.                         $this->process_SOFn($data,$marker);
    599. 

  599.                         $this->debug("<br>M_SOFn Section, PROCESSED<br>");
    600. 

  600.                 break;
    601. 

  601. 				case M_EXIF_EXT: // 226 - Exif Extended Data
    602. 

  602. 				    $this->debug("<br><b>Found 'Exif Extended Data' Section, Processing</b><br>-------------------------------<br>");
    603. 

  603.                     $this->process_EXT_EXIF($data, $itemlen);
    604. 

  604. 					$this->debug("<br>--------------------------PROCESSED<br>");
    605. 

  605. 					break;
    606. 

  606. 

  607. 				case M_QUANTA: // 219 - Quantisation Table Definition
    608. 

  608. 				    $this->debug("<br><b>Found 'Quantisation Table Definition' Section, Processing</b><br>-------------------------------<br>");
    609. 

  609. 					$this->debug("<br>--------------------------PROCESSED<br>");
    610. 

  610. 					break;
    611. 

  611. 

  612. 				case M_HUFF: // Huffman Table
    613. 

  613. 				    $this->debug("<br><b>Found 'Huffman Table' Section, Processing</b><br>-------------------------------<br>");
    614. 

  614. 					$this->debug("<br>--------------------------PROCESSED<br>");
    615. 

  615. 					break;
    616. 

  616. 

  617.                 default:
    618. 

  618.                         $this->debug("DEFAULT: Jpeg section marker 0x$marker x size $itemlen\n");
    619. 

  619.         }
    620. 

  620.         $i++;
    621. 

  621.         if($exitAll == 1)  break;
    622. 

  622.             //if($tmpTestLevel == 2)  break;
    623. 

  623.         }
    624. 

  624.         fclose($fp);
    625. 

  625.         $this->newFile = 0;
    626. 

  626.     }
    627. 

  627. 

  628.     /**
    629. 

  629.      * Changing / Assiging new file
    630. 

  630.      * @param   string    JPEG file to process
    631. 

  631.      *
    632. 

  632.      */
    633. 

  633.     function assign($file) {
    634. 

  634. 

  635.       if(!empty($file)) {
    636. 

  636.         $this->file = $file;
    637. 

  637.       }
    638. 

  638. 

  639.       /** check for existance of file! */
    640. 

  640.       if(!file_exists($this->file)) {
    641. 

  641.          $this->errorno = 1;
    642. 

  642.          $this->errorstr = "File '".$this->file."' does not exists!";
    643. 

  643.       }
    644. 

  644.       $this->newFile = 1;
    645. 

  645.     }
    646. 

  646. 

  647.     /**
    648. 

  648.      * Process SOFn section of Image
    649. 

  649.      * @param  array    An array containing whole section.
    650. 

  650.      * @param   hex  Marker to specify the type of section.
    651. 

  651.      *
    652. 

  652.      */
    653. 

  653.     function process_SOFn($data,$marker) {
    654. 

  654.         $data_precision = 0;
    655. 

  655.         $num_components = 0;
    656. 

  656. 

  657.         $data_precision = ord($data[2]);
    658. 

  658. 

  659.         if($this->debug) {
    660. 

  660.           print("Image Dimension Calculation:");
    661. 

  661.           print("((ord($data[3]) << 8) | ord($data[4]));");
    662. 

  662.         }
    663. 

  663.         $this->ImageInfo["h"]["Height"] = ((ord($data[3]) << 8) | ord($data[4]));
    664. 

  664.         $this->ImageInfo["h"]["Width"] = ((ord($data[5]) << 8) | ord($data[6]));
    665. 

  665. 

  666.         $num_components = ord($data[7]);
    667. 

  667. 

  668.         if ($num_components == 3){
    669. 

  669.             $this->ImageInfo["h"]["IsColor"] = 1;
    670. 

  670.         }else{
    671. 

  671.             $this->ImageInfo["h"]["IsColor"] = 0;
    672. 

  672.         }
    673. 

  673. 

  674.         $this->ImageInfo["h"]["Process"] = $marker;
    675. 

  675.         $this->debug("JPEG image is ".$this->ImageInfo["h"]["Width"]." * ".$this->ImageInfo["h"]["Height"].", $num_components color components, $data_precision bits per sample\n");
    676. 

  676.     }
    677. 

  677. 

  678.     /**
    679. 

  679.      * Process Comments
    680. 

  680.      * @param   array    Section data
    681. 

  681.      * @param   int  Length of the section
    682. 

  682.      *
    683. 

  683.      */
    684. 

  684.     function process_COM($data,$length) {
    685. 

  685.         if ($length > MAX_COMMENT) $length = MAX_COMMENT;
    686. 

  686.             /** Truncate if it won't fit in our structure. */
    687. 

  687. 

  688.         $nch = 0; $Comment = "";
    689. 

  689.         for ($a=2;$a<$length;$a++){
    690. 

  690.             $ch = $data[$a];
    691. 

  691.             if ($ch == '\r' && $data[$a+1] == '\n') continue; // Remove cr followed by lf.
    692. 

  692. 

  693.             $Comment .= $ch;
    694. 

  694.         }
    695. 

  695.         //$this->ImageInfo[M_COM] = $Comment;
    696. 

  696.         $this->ImageInfo["h"]["imageComment"] = $this->string_format($Comment);
    697. 

  697.         $this->debug("COM marker comment: $Comment\n");
    698. 

  698.     }
    699. 

  699.     /**
    700. 

  700.      * Process one of the nested EXIF directories.
    701. 

  701.      * @param   string        All directory information
    702. 

  702.      * @param   string     whole Section
    703. 

  703.      * @param   int  Length of exif section
    704. 

  704.      *
    705. 

  705.     */
    706. 

  706.     function ProcessExifDir($DirStart, $OffsetBase, $ExifLength) {
    707. 

  707. 

  708.         $NumDirEntries = 0;
    709. 

  709.         $ValuePtr = array();
    710. 

  710. 

  711.         $NumDirEntries = $this->Get16u($DirStart[0],$DirStart[1]);
    712. 

  712. 

  713. 

  714.         $this->debug("<br>Directory with $NumDirEntries entries\n");
    715. 

  715. 

  716.         for ($de=0;$de<$NumDirEntries;$de++){
    717. 

  717.             //$DirEntry = array_slice($DirStart,2+12*$de);
    718. 

  718.             $DirEntry = substr($DirStart,2+12*$de);
    719. 

  719. 

  720.             $Tag = $this->Get16u($DirEntry[0],$DirEntry[1]);
    721. 

  721.             $Format = $this->Get16u($DirEntry[2],$DirEntry[3]);
    722. 

  722.             $Components = $this->Get32u($DirEntry[4],$DirEntry[5],$DirEntry[6],$DirEntry[7]);
    723. 

  723. 

  724.             /**
    725. 

  725.             if ((Format-1) >= NUM_FORMATS) {
    726. 

  726.                 // (-1) catches illegal zero case as unsigned underflows to positive large.
    727. 

  727.                 ErrNonfatal("Illegal number format %d for tag %04x", Format, Tag);
    728. 

  728.                 continue;
    729. 

  729.             }
    730. 

  730.             */
    731. 

  731. 

  732.             $ByteCount = $Components * $this->BytesPerFormat[$Format];
    733. 

  733. 

  734.             if ($ByteCount > 4){
    735. 

  735.                 $OffsetVal = $this->Get32u($DirEntry[8],$DirEntry[9],$DirEntry[10],$DirEntry[11]);
    736. 

  736.                 if ($OffsetVal+$ByteCount > $ExifLength){
    737. 

  737.                     $this->debug("Illegal value pointer($OffsetVal) for tag $Tag",1);
    738. 

  738.                 }
    739. 

  739.                 //$ValuePtr = array_slice($OffsetBase,$OffsetVal);
    740. 

  740.                 $ValuePtr = substr($OffsetBase,$OffsetVal);
    741. 

  741.             } else {
    742. 

  742.                 //$ValuePtr = array_slice($DirEntry,8);
    743. 

  743.                 $ValuePtr = substr($DirEntry,8);
    744. 

  744.             }
    745. 

  745. 

  746.             switch($Tag){
    747. 

  747. 

  748.                 case TAG_MAKE:
    749. 

  749.                     $this->ImageInfo["h"]["make"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    750. 

  750.                     break;
    751. 

  751. 

  752.                 case TAG_MODEL:
    753. 

  753.                     $this->ImageInfo["h"]["model"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    754. 

  754.                     break;
    755. 

  755. 

  756.                 case TAG_DATETIME_ORIGINAL:
    757. 

  757.                     $this->ImageInfo[TAG_DATETIME_ORIGINAL] =  $this->string_format(substr($ValuePtr,0,$ByteCount));
    758. 

  758.                     $this->ImageInfo["h"]["DateTime"]  = $this->string_format(substr($ValuePtr,0,$ByteCount));
    759. 

  759.                     break;
    760. 

  760. 

  761.                 case TAG_USERCOMMENT:
    762. 

  762.                     // Olympus has this padded with trailing spaces.  Remove these first.
    763. 

  763.                     for ($a=$ByteCount;;){
    764. 

  764.                         $a--;
    765. 

  765.                         if ($ValuePtr[$a] == ' '){
    766. 

  766.                             //$ValuePtr[$a] = '\0';
    767. 

  767.                         } else {
    768. 

  768.                             break;
    769. 

  769.                         }
    770. 

  770.                         if ($a == 0) break;
    771. 

  771.                     }
    772. 

  772. 

  773.                     // Copy the comment
    774. 

  774.                     if (($ValuePtr[0].$ValuePtr[1].$ValuePtr[2].$ValuePtr[3].$ValuePtr[4]) == "ASCII"){
    775. 

  775.                         for ($a=5;$a<10;$a++){
    776. 

  776.                             $c = $ValuePtr[$a];
    777. 

  777.                             if ($c != '\0' && $c != ' '){
    778. 

  778.                                 $tmp = substr($ValuePtr,0,$ByteCount);
    779. 

  779.                                     break;
    780. 

  780.                             }
    781. 

  781.                         }
    782. 

  782.                     } else if (($ValuePtr[0].$ValuePtr[1].$ValuePtr[2].$ValuePtr[3].$ValuePtr[4].$ValuePtr[5].$ValuePtr[6]) == "Unicode"){
    783. 

  783.                         $tmp = substr($ValuePtr,0,$ByteCount);
    784. 

  784.                         //  * Handle Unicode characters here...
    785. 

  785.                     } else {
    786. 

  786.                         //$this->ImageInfo[TAG_USERCOMMENT] = implode("",array_slice($ValuePtr,0,$ByteCount));
    787. 

  787.                         $tmp = substr($ValuePtr,0,$ByteCount);
    788. 

  788.                     }
    789. 

  789.                     $this->ImageInfo['h']["exifComment"] = $this->string_format($tmp);
    790. 

  790.                     break;
    791. 

  791. 

  792. 				case TAG_ARTIST:
    793. 

  793.                     $this->ImageInfo['h']["artist"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    794. 

  794. 					break;
    795. 

  795. 

  796. 				case TAG_COPYRIGHT:
    797. 

  797.                     $this->ImageInfo['h']["copyright"] = htmlentities(substr($ValuePtr,0,$ByteCount));
    798. 

  798. 					break;
    799. 

  799. 

  800.                 case TAG_FNUMBER:
    801. 

  801.                     // Simplest way of expressing aperture, so I trust it the most.
    802. 

  802.                     // (overwrite previously computd value if there is one)
    803. 

  803.                     $tmp = $this->ConvertAnyFormat(substr($ValuePtr,0), $Format);
    804. 

  804.                     $this->ImageInfo['h']["fnumber"] = sprintf("f/%3.1f",(double)$tmp[0]);
    805. 

  805.                     break;
    806. 

  806. 

  807.                 case TAG_APERTURE:
    808. 

  808.                 case TAG_MAXAPERTURE:
    809. 

  809.                     // More relevant info always comes earlier, so only use this field if we don't
    810. 

  810.                     // have appropriate aperture information yet.
    811. 

  811.                     if (!isset($this->ImageInfo['h']["aperture"])){
    812. 

  812.                         $tmpArr =  $this->ConvertAnyFormat($ValuePtr, $Format);
    813. 

  813.                         $this->ImageInfo['h']["aperture"] = exp($tmpArr[0]*log(2)*0.5);
    814. 

  814.                     }
    815. 

  815.                     break;
    816. 

  816. 

  817.                 case TAG_FOCALLENGTH:
    818. 

  818.                     // Nice digital cameras actually save the focal length as a function
    819. 

  819.                     // of how farthey are zoomed in.
    820. 

  820.                     $tmp = $this->ConvertAnyFormat($ValuePtr, $Format);
    821. 

  821.                     $this->ImageInfo['h']["focalLength"] = sprintf("%4.2f (%d/%d)",(double)$tmp[0],$tmp[1][0],$tmp[1][1]);
    822. 

  822.                     if (isset($this->ImageInfo['h']["CCDWidth"])){
    823. 

  823.                         $this->ImageInfo['h']["focalLength"] .= sprintf("(35mm equivalent: %dmm)",(int)($tmp[0]/$this->ImageInfo['h']["CCDWidth"]*36 + 0.5));
    824. 

  824.                     }
    825. 

  825.                     break;
    826. 

  826. 

  827.                 case TAG_SUBJECT_DISTANCE:
    828. 

  828.                     // Inidcates the distacne the autofocus camera is focused to.
    829. 

  829.                     // Tends to be less accurate as distance increases.
    830. 

  830.                     //$this->ImageInfo["h"]["Distance"] =  $this->ConvertAnyFormat($ValuePtr, $Format);
    831. 

  831.                     $tmp = $this->ConvertAnyFormat($ValuePtr, $Format);
    832. 

  832.                     $this->ImageInfo['h']["Distance"] = sprintf("%4.2f (%d/%d)",(double)$tmp[0],$tmp[1][0],$tmp[1][1]);
    833. 

  833.                     if ($this->ImageInfo['h']["Distance"] < 0){
    834. 

  834.                             $this->ImageInfo['h']["focusDistance"] = "Infinite";
    835. 

  835.                     } else {
    836. 

  836.                             $this->ImageInfo['h']["focusDistance"] = sprintf("%4.2fm",(double)$this->ImageInfo['h']["Distance"]);
    837. 

  837.                     }
    838. 

  838. 

  839. 

  840.                     break;
    841. 

  841. 

  842.                 case TAG_EXPOSURETIME:
    843. 

  843.                     // Simplest way of expressing exposure time, so I trust it most.
    844. 

  844.                     // (overwrite previously computd value if there is one)
    845. 

  845.                     $tmp = $this->ConvertAnyFormat($ValuePtr, $Format);
    846. 

  846.                     $this->ImageInfo['h']["exposureTime"] = sprintf("%6.3f s (%d/%d)",(double)$tmp[0],$tmp[1][0],$tmp[1][1]);
    847. 

  847.                     if ($tmp[0] <= 0.5){
    848. 

  848.                             $this->ImageInfo['h']["exposureTime"] .= sprintf(" (1/%d)",(int)(0.5 + 1/$tmp[0]));
    849. 

  849.                     }
    850. 

  850.                     break;
    851. 

  851. 

  852.                 case TAG_SHUTTERSPEED:
    853. 

  853.                     // More complicated way of expressing exposure time, so only use
    854. 

  854.                     // this value if we don't already have it from somewhere else.
    855. 

  855.                     if ($this->ImageInfo[TAG_EXPOSURETIME] == 0){
    856. 

  856.                         $sp = $this->ConvertAnyFormat($ValuePtr, $Format);
    857. 

  857.                         // Temporary Workaround for divizion by zero problem
    858. 

  858.                         if (!empty($sp[0])) {
    859. 

  859.                             $this->ImageInfo[TAG_SHUTTERSPEED] = (1/exp($sp[0]*log(2)));
    860. 

  860.                         } else {
    861. 

  861.                             $this->ImageInfo[TAG_SHUTTERSPEED] = 0;
    862. 

  862.                         }
    863. 

  863.                     }
    864. 

  864.                     break;
    865. 

  865. 

  866.                 case TAG_FLASH:
    867. 

  867.                     $this->ImageInfo["h"]["flashUsed"] = "No";
    868. 

  868.                     if ($this->ConvertAnyFormat($ValuePtr, $Format) & 7){
    869. 

  869.                         $this->ImageInfo["h"]["flashUsed"] = "Yes";
    870. 

  870.                     }
    871. 

  871.                     break;
    872. 

  872. 

  873.                 case TAG_ORIENTATION:
    874. 

  874.                     $this->ImageInfo[TAG_ORIENTATION] = $this->ConvertAnyFormat($ValuePtr, $Format);
    875. 

  875.                     if ($this->ImageInfo[TAG_ORIENTATION] < 1 || $this->ImageInfo[TAG_ORIENTATION] > 8){
    876. 

  876.                             $this->debug(sprintf("Undefined rotation value %d", $this->ImageInfo[TAG_ORIENTATION], 0),1);
    877. 

  877.                         $this->ImageInfo[TAG_ORIENTATION] = 0;
    878. 

  878.                     }
    879. 

  879.                     break;
    880. 

  880. 

  881.                 case TAG_EXIF_IMAGELENGTH:
    882. 

  882.                     //       * Image height
    883. 

  883.                     $a = (int) $this->ConvertAnyFormat($ValuePtr, $Format);
    884. 

  884.                     if ($this->ExifImageLength < $a) $this->ExifImageLength = $a;
    885. 

  885.                     $this->ImageInfo[TAG_EXIF_IMAGELENGTH] = $this->ExifImageLength;
    886. 

  886.                     $this->ImageInfo["h"]["Height"] = $this->ExifImageLength;
    887. 

  887.                     break;
    888. 

  888.                 case TAG_EXIF_IMAGEWIDTH:
    889. 

  889.                     // Use largest of height and width to deal with images that have been
    890. 

  890.                     // rotated to portrait format.
    891. 

  891.                     $a = (int) $this->ConvertAnyFormat($ValuePtr, $Format);
    892. 

  892.                     if ($this->ExifImageWidth < $a) $this->ExifImageWidth = $a;
    893. 

  893.                     $this->ImageInfo[TAG_EXIF_IMAGEWIDTH] = $this->ExifImageWidth;
    894. 

  894.                     $this->ImageInfo["h"]["Width"] = $this->ExifImageWidth;
    895. 

  895. 

  896.                     break;
    897. 

  897. 

  898.                 case TAG_FOCALPLANEXRES:
    899. 

  899.                     $this->FocalplaneXRes = $this->ConvertAnyFormat($ValuePtr, $Format);
    900. 

  900.                     $this->FocalplaneXRes = $this->FocalplaneXRes[0];
    901. 

  901.                     $this->ImageInfo[TAG_FOCALPLANEXRES] = $this->FocalplaneXRes[0];
    902. 

  902.                     break;
    903. 

  903. 

  904.                 case TAG_FOCALPLANEUNITS:
    905. 

  905.                     switch($this->ConvertAnyFormat($ValuePtr, $Format)){
    906. 

  906.                         case 1: $this->FocalplaneUnits = 25.4; break; // inch
    907. 

  907.                         case 2:
    908. 

  908.                             // According to the information I was using, 2 means meters.
    909. 

  909.                             // But looking at the Cannon powershot's files, inches is the only
    910. 

  910.                             // sensible value.
    911. 

  911.                             $this->FocalplaneUnits = 25.4;
    912. 

  912.                             break;
    913. 

  913. 

  914.                         case 3: $this->FocalplaneUnits = 10;   break;  // centimeter
    915. 

  915.                         case 4: $this->FocalplaneUnits = 1;    break;  // milimeter
    916. 

  916.                         case 5: $this->FocalplaneUnits = .001; break;  // micrometer
    917. 

  917.                     }
    918. 

  918.                     $this->ImageInfo[TAG_FOCALPLANEUNITS] = $this->FocalplaneUnits;
    919. 

  919.                     break;
    920. 

  920. 

  921.                     // Remaining cases contributed by: Volker C. Schoech (schoech@gmx.de)
    922. 

  922. 

  923.                 case TAG_EXPOSURE_BIAS:
    924. 

  924.                     $tmp = $this->ConvertAnyFormat($ValuePtr, $Format);
    925. 

  925.                     $this->ImageInfo['h']["exposureBias"] = sprintf("%4.2f (%d/%d)",(double)$tmp[0],$tmp[1][0],$tmp[1][1]);
    926. 

  926.                     break;
    927. 

  927. 

  928.                 case TAG_WHITEBALANCE:
    929. 

  929.                     $tmp = (int) $this->ConvertAnyFormat($ValuePtr, $Format);
    930. 

  930.                     $tmpArr = array("1"=>"Sunny","2"=>"fluorescent","3"=>"incandescent");
    931. 

  931.                     $this->ImageInfo['h']["whiteBalance"] =
    932. 

  932.                         (isset($tmpArr["$tmp"]) ? $tmpArr["$tmp"] : "Cloudy");
    933. 

  933.                     break;
    934. 

  934. 

  935.                 case TAG_METERING_MODE:
    936. 

  936.                     $tmp = (int) $this->ConvertAnyFormat($ValuePtr, $Format);
    937. 

  937. 

  938.                     $tmpArr = array("2"=>"center weight","3"=>"spot","5"=>"matrix");
    939. 

  939.                     $this->ImageInfo['h']["meteringMode"] =
    940. 

  940.                         (isset($tmpArr["$tmp"]) ? $tmpArr["$tmp"] : "Reserved");
    941. 

  941.                     break;
    942. 

  942. 

  943.                 case TAG_EXPOSURE_PROGRAM:
    944. 

  944.                     $tmp = (int) $this->ConvertAnyFormat($ValuePtr, $Format);
    945. 

  945.                     $tmpArr = array("2"=>"program (auto)","3"=>"aperture priority (semi-auto)","4"=>"shutter priority (semi-auto)");
    946. 

  946.                     $this->ImageInfo['h']["exposure"] =
    947. 

  947.                         (isset($tmpArr["$tmp"]) ? $tmpArr["$tmp"] : "Reserved");
    948. 

  948. 

  949.                     break;
    950. 

  950. 

  951.                 case TAG_ISO_EQUIVALENT:
    952. 

  952.                     $tmp = (int) $this->ConvertAnyFormat($ValuePtr, $Format);
    953. 

  953.                     if ( $tmp < 50 ) $tmp *= 200;
    954. 

  954.                     $this->ImageInfo['h']["isoEquiv"] = sprintf("%2d",(int)$tmp);
    955. 

  955.                     break;
    956. 

  956. 

  957.                 case TAG_COMPRESSION_LEVEL:
    958. 

  958.                     $tmp = (int) $this->ConvertAnyFormat($ValuePtr, $Format);
    959. 

  959.                     $tmpArr = array("1"=>"Basic","2"=>"Normal","4"=>"Fine");
    960. 

  960.                     $this->ImageInfo['h']["jpegQuality"] =
    961. 

  961.                         (isset($tmpArr["$tmp"]) ? $tmpArr["$tmp"] : "Reserved");
    962. 

  962.                     break;
    963. 

  963. 

  964.                 case TAG_THUMBNAIL_OFFSET:
    965. 

  965.                     $this->ThumbnailOffset = $this->ConvertAnyFormat($ValuePtr, $Format);
    966. 

  966.                     $this->DirWithThumbnailPtrs = $DirStart;
    967. 

  967.                     break;
    968. 

  968. 

  969.                 case TAG_THUMBNAIL_LENGTH:
    970. 

  970.                     $this->ThumbnailSize = $this->ConvertAnyFormat($ValuePtr, $Format);
    971. 

  971.                     $this->ImageInfo[TAG_THUMBNAIL_LENGTH] = $this->ThumbnailSize;
    972. 

  972.                     break;
    973. 

  973. 

  974.                 //----------------------------------------------
    975. 

  975.                 case TAG_IMAGE_DESC:
    976. 

  976.                         $this->ImageInfo['h']["imageDesc"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    977. 

  977.                         break;
    978. 

  978.                 case TAG_X_RESOLUTION:
    979. 

  979.                         $tmp = $this->ConvertAnyFormat($ValuePtr, $Format);
    980. 

  980.                         $this->ImageInfo['h']["xResolution"] = sprintf("%4.2f (%d/%d) %s",(double)$tmp[0],$tmp[1][0],$tmp[1][1],$this->ImageInfo['h']["resolutionUnit"]);
    981. 

  981.                         break;
    982. 

  982.                 case TAG_Y_RESOLUTION:
    983. 

  983.                         $tmp = $this->ConvertAnyFormat($ValuePtr, $Format);
    984. 

  984.                         $this->ImageInfo['h']["yResolution"] = sprintf("%4.2f (%d/%d) %s",(double)$tmp[0],$tmp[1][0],$tmp[1][1],$this->ImageInfo['h']["resolutionUnit"]);
    985. 

  985.                         break;
    986. 

  986.                 case TAG_RESOLUTION_UNIT:
    987. 

  987.                         $tmp = $this->ConvertAnyFormat($ValuePtr, $Format);
    988. 

  988.                         $tmpArr = array("2"=>"Inches","3"=>"Centimeters");
    989. 

  989. 

  990.                         $this->ImageInfo['h']["resolutionUnit"] =
    991. 

  991.                             (isset($tmpArr["$tmp"]) ? $tmpArr["$tmp"] : "Reserved");
    992. 

  992.                         break;
    993. 

  993.                 case TAG_SOFTWARE:
    994. 

  994.                         $this->ImageInfo['h']["software"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    995. 

  995.                         break;
    996. 

  996.                 case TAG_FILE_MODDATE;
    997. 

  997.                         $this->ImageInfo['h']["fileModifiedDate"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    998. 

  998.                         break;
    999. 

  999.                 case TAG_YCBCR_POSITIONING:
    1000. 

  1000.                         $this->ImageInfo['h']["YCbCrPositioning"] = $this->ConvertAnyFormat($ValuePtr, $Format);
    1001. 

  1001.                         break;
    1002. 

  1002.                 case TAG_EXIF_VERSION:
    1003. 

  1003.                         $this->ImageInfo['h']["exifVersion"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1004. 

  1004.                         break;
    1005. 

  1005.                 case TAG_DATE_TIME_DIGITIZED:
    1006. 

  1006.                         $this->ImageInfo['h']["dateTimeDigitized"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1007. 

  1007.                         break;
    1008. 

  1008.                 case TAG_COMPONENT_CONFIG: // need more tests for this
    1009. 

  1009.                         $tmp = (int)$this->ConvertAnyFormat($ValuePtr, $Format);
    1010. 

  1010. 

  1011.                         $tmpArr = array("0"=>"Does Not Exists","1"=>"Y","2"=>"Cb","3"=>"Cr","4"=>"R","5"=>"G","6"=>"B");
    1012. 

  1012. 

  1013.                         if(strlen($tmp) < 4 ) {
    1014. 

  1014.                             $this->ImageInfo['h']["componentConfig"] = $tmpArr["0"];
    1015. 

  1015.                         } else {
    1016. 

  1016.                             for($i=0;$i<strlen($tmp);$i++) {
    1017. 

  1017.                                 if($tmp["$i"] != 0) {
    1018. 

  1018.                                     $this->ImageInfo['h']["componentConfig"] .= $tmpArr[$tmp["$i"]];
    1019. 

  1019.                                 }
    1020. 

  1020.                             }
    1021. 

  1021.                         }
    1022. 

  1022.                         break;
    1023. 

  1023.                 case TAG_MAKER_NOTE:
    1024. 

  1024.                         //$this->ImageInfo['h']["makerNote"] = substr($ValuePtr,0,$ByteCount);
    1025. 

  1025.                         $this->ImageInfo['h']["makerNote"] = "NOT IMPLEMENTED";
    1026. 

  1026.                         break;
    1027. 

  1027.                 case TAG_SUB_SEC_TIME:
    1028. 

  1028.                         $this->ImageInfo['h']["subSectionTime"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1029. 

  1029.                         break;
    1030. 

  1030.                 case TAG_SUB_SEC_TIME_ORIG:
    1031. 

  1031.                         $this->ImageInfo['h']["subSectionTimeOriginal"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1032. 

  1032.                         break;
    1033. 

  1033.                 case TAG_SUB_SEC_TIME_DIGITIZED:
    1034. 

  1034.                         $this->ImageInfo['h']["subSectionTimeDigtized"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1035. 

  1035.                         break;
    1036. 

  1036.                 case TAG_FLASHPIX_VER:
    1037. 

  1037.                         $this->ImageInfo['h']["flashpixVersion"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1038. 

  1038.                         break;
    1039. 

  1039.                 case TAG_COLOR_SPACE:
    1040. 

  1040.                         $this->ImageInfo['h']["colorSpace"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1041. 

  1041.                         break;
    1042. 

  1042.                 case TAG_RELATED_SOUND_FILE:
    1043. 

  1043.                         $this->ImageInfo['h']["relatedSoundFile"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1044. 

  1044.                         break;
    1045. 

  1045.                 case TAG_GPS_LATITUDE_REF:
    1046. 

  1046.                         $this->ImageInfo['h']["GPSLatitudeRef"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1047. 

  1047. 						$this->ImageInfo['h']["GPSLatitudeRef"] = trim($this->ImageInfo['h']["GPSLatitudeRef"]);
    1048. 

  1048. 						$tmp = substr($this->ImageInfo['h']["GPSLatitudeRef"],0,1);
    1049. 

  1049. 						if($tmp == "S") {
    1050. 

  1050. 							$this->ImageInfo['h']["GPSLatitudeRef"] = "South latitude";
    1051. 

  1051. 						} else if($tmp == "N") {
    1052. 

  1052. 							$this->ImageInfo['h']["GPSLatitudeRef"] = "North latitude";
    1053. 

  1053. 						} else {
    1054. 

  1054. 							$this->ImageInfo['h']["GPSLatitudeRef"] = "Reserved";
    1055. 

  1055. 						}
    1056. 

  1056.                         break;
    1057. 

  1057.                 case TAG_GPS_LATITUDE:
    1058. 

  1058. 						$degrees = $this->ConvertAnyFormat( substr($ValuePtr,0,8), FMT_URATIONAL);
    1059. 

  1059. 						$degrees = $degrees[0];
    1060. 

  1060. 						$minutes = $this->ConvertAnyFormat( substr($ValuePtr,8,8), FMT_URATIONAL);
    1061. 

  1061. 						$minutes = $minutes[0];
    1062. 

  1062. 						$seconds = $this->ConvertAnyFormat( substr($ValuePtr,16,8), FMT_URATIONAL);
    1063. 

  1063. 						$seconds = $seconds[0];
    1064. 

  1064. 

  1065. 						$this->ImageInfo['h']["GPSLatitude"]["Degrees"] = $degrees;
    1066. 

  1066. 						$this->ImageInfo['h']["GPSLatitude"]["Minutes"] = $minutes;
    1067. 

  1067. 						$this->ImageInfo['h']["GPSLatitude"]["Seconds"] = $seconds;
    1068. 

  1068.                         break;
    1069. 

  1069. 

  1070.                 case TAG_GPS_LONGITUDE:
    1071. 

  1071. 

  1072. 						$degrees = $this->ConvertAnyFormat( substr($ValuePtr,0,8), FMT_URATIONAL);
    1073. 

  1073. 						$degrees = $degrees[0];
    1074. 

  1074. 						$minutes = $this->ConvertAnyFormat( substr($ValuePtr,8,8), FMT_URATIONAL);
    1075. 

  1075. 						$minutes = $minutes[0];
    1076. 

  1076. 						$seconds = $this->ConvertAnyFormat( substr($ValuePtr,16,8), FMT_URATIONAL);
    1077. 

  1077. 						$seconds = $seconds[0];
    1078. 

  1078. 

  1079. 						$this->ImageInfo['h']["GPSLongitude"]["Degrees"] = $degrees;
    1080. 

  1080. 						$this->ImageInfo['h']["GPSLongitude"]["Minutes"] = $minutes;
    1081. 

  1081. 						$this->ImageInfo['h']["GPSLongitude"]["Seconds"] = $seconds;
    1082. 

  1082.                         break;
    1083. 

  1083. 

  1084.                 case TAG_GPS_LONGITUDE_REF:
    1085. 

  1085.                         $this->ImageInfo['h']["GPSLongitudeRef"] = substr($ValuePtr,0,$ByteCount);
    1086. 

  1086. 						$this->ImageInfo['h']["GPSLongitudeRef"] = trim($this->ImageInfo['h']["GPSLongitudeRef"]);
    1087. 

  1087. 						$tmp = substr($this->ImageInfo['h']["GPSLongitudeRef"],0,1);
    1088. 

  1088. 						if($tmp == "E") {
    1089. 

  1089. 							$this->ImageInfo['h']["GPSLongitudeRef"] = "East Longitude";
    1090. 

  1090. 						} else if($tmp == "W") {
    1091. 

  1091. 							$this->ImageInfo['h']["GPSLongitudeRef"] = "West Longitude";
    1092. 

  1092. 						} else {
    1093. 

  1093. 							$this->ImageInfo['h']["GPSLongitudeRef"] = "Reserved";
    1094. 

  1094. 						}
    1095. 

  1095. 

  1096.                         break;
    1097. 

  1097. 

  1098. 

  1099. 				case TAG_GPS_TrackRef: /* Reference for direction of movement    GPSTrackRef */
    1100. 

  1100. 					$this->ImageInfo['h']["GPSTrackRef"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1101. 

  1101. 					break;
    1102. 

  1102. 

  1103. 

  1104. 				case TAG_GPS_GPSTrack: /* Direction of movement					GPSTrack */
    1105. 

  1105. 					$this->ImageInfo['h']["GPSTrack"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1106. 

  1106. 					break;
    1107. 

  1107. 				case TAG_GPS_GPSImgDirectionRef: /* Reference for direction of image       GPSImgDirectionRef */
    1108. 

  1108. 					$this->ImageInfo['h']["GPSImgDirectionRef"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1109. 

  1109. 					break;
    1110. 

  1110. 				case TAG_GPS_GPSImgDirection: /* Direction of image                     GPSImgDirection     */
    1111. 

  1111. 					$this->ImageInfo['h']["GPSImgDirection"] = $this->ConvertAnyFormat($ValuePtr, $Format);
    1112. 

  1112. 					break;
    1113. 

  1113. 				case TAG_GPS_GPSMapDatum: /* Geodetic survey data used              GPSMapDatum         */
    1114. 

  1114. 					$this->ImageInfo['h']["GPSMapDatum"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1115. 

  1115. 					break;
    1116. 

  1116. 				case TAG_GPS_GPSDestLatitudeRef:/* Reference for latitude of destination  GPSDestLatitudeRef  */
    1117. 

  1117. 					$this->ImageInfo['h']["GPSDestLatitudeRef"] = substr($ValuePtr,0,$ByteCount);
    1118. 

  1118. 					$this->ImageInfo['h']["GPSDestLatitudeRef"] = trim($this->ImageInfo['h']["GPSDestLatitudeRef"]);
    1119. 

  1119. 					$tmp = substr($this->ImageInfo['h']["GPSDestLatitudeRef"],0,1);
    1120. 

  1120. 					if($tmp == "S") {
    1121. 

  1121. 						$this->ImageInfo['h']["GPSDestLatitudeRef"] = "South latitude";
    1122. 

  1122. 					} else if($tmp == "N") {
    1123. 

  1123. 						$this->ImageInfo['h']["GPSDestLatitudeRef"] = "North latitude";
    1124. 

  1124. 					} else {
    1125. 

  1125. 						$this->ImageInfo['h']["GPSDestLatitudeRef"] = "Reserved";
    1126. 

  1126. 					}
    1127. 

  1127. 

  1128. 					break;
    1129. 

  1129. 				case TAG_GPS_GPSDestLatitude:/* Latitude of destination                GPSDestLatitude     */
    1130. 

  1130. 						$tmp = substr($ValuePtr,0,$ByteCount);
    1131. 

  1131. 

  1132. 						$this->ImageInfo['h']["GPSDestLatitude"]["Degrees"] = ord(substr($tmp,0,1));
    1133. 

  1133. 						$this->ImageInfo['h']["GPSDestLatitude"]["Minutes"] = ord(substr($tmp,1,1));
    1134. 

  1134. 						$this->ImageInfo['h']["GPSDestLatitude"]["Seconds"] = ord(substr($tmp,2,1));
    1135. 

  1135. 

  1136. 					break;
    1137. 

  1137. 				case TAG_GPS_GPSDestLongitudeRef:/* Reference for longitude of destination GPSDestLongitudeRef 21     */
    1138. 

  1138. 					$this->ImageInfo['h']["GPSDestLongitudeRef"] = substr($ValuePtr,0,$ByteCount);
    1139. 

  1139. 					$this->ImageInfo['h']["GPSDestLongitudeRef"] = trim($this->ImageInfo['h']["GPSDestLongitudeRef"]);
    1140. 

  1140. 					$tmp = substr($this->ImageInfo['h']["GPSDestLongitudeRef"],0,1);
    1141. 

  1141. 					if($tmp == "E") {
    1142. 

  1142. 						$this->ImageInfo['h']["GPSDestLongitudeRef"] = "East Longitude";
    1143. 

  1143. 					} else if($tmp == "W") {
    1144. 

  1144. 						$this->ImageInfo['h']["GPSDestLongitudeRef"] = "West Longitude";
    1145. 

  1145. 					} else {
    1146. 

  1146. 						$this->ImageInfo['h']["GPSDestLongitudeRef"] = "Reserved";
    1147. 

  1147. 					}
    1148. 

  1148. 

  1149. 					break;
    1150. 

  1150. 				case TAG_GPS_GPSDestLongitude:/* Longitude of destination               GPSDestLongitude    22     */
    1151. 

  1151. 					$this->ImageInfo['h']["GPSDestLongitude"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1152. 

  1152. 					break;
    1153. 

  1153. 				case TAG_GPS_GPSDestBearingRef:/* Reference for bearing of destination   GPSDestBearingRef   23     */
    1154. 

  1154. 					$this->ImageInfo['h']["GPSDestBearingRef"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1155. 

  1155. 					break;
    1156. 

  1156. 				case TAG_GPS_GPSDestBearing: /* Bearing of destination                 GPSDestBearing      24     */
    1157. 

  1157. 					$this->ImageInfo['h']["GPSDestBearing"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1158. 

  1158. 					break;
    1159. 

  1159. 				case TAG_GPS_GPSDestDistanceRef:/* Reference for distance to destination  GPSDestDistanceRef  25     */
    1160. 

  1160. 					$this->ImageInfo['h']["GPSDestDistanceRef"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1161. 

  1161. 					break;
    1162. 

  1162. 				case TAG_GPS_GPSDestDistance: /* Distance to destination                GPSDestDistance     26     */
    1163. 

  1163. 					//$this->ImageInfo['h']["GPSDestDistance"] = $this->ConvertAnyFormat($ValuePtr, $Format);
    1164. 

  1164. 					$tmp = $this->ConvertAnyFormat($ValuePtr, $Format);
    1165. 

  1165. 					$this->ImageInfo['h']["GPSDestDistance"] = sprintf("%4.2f (%d/%d)",(double)$tmp[0],$tmp[1][0],$tmp[1][1]);;
    1166. 

  1166. 					break;
    1167. 

  1167. 				case TAG_GPS_GPSProcessingMethod: /* Name of GPS processing method          GPSProcessingMethod 27     */
    1168. 

  1168. 					//$this->ImageInfo['h']["GPSProcessingMethod"] = $this->ConvertAnyFormat($ValuePtr, $Format);
    1169. 

  1169. 					$tmp = $this->ConvertAnyFormat($ValuePtr, $Format);
    1170. 

  1170. 					$this->ImageInfo['h']["GPSProcessingMethod"] = sprintf("%4.2f (%d/%d)",(double)$tmp[0],$tmp[1][0],$tmp[1][1]);;
    1171. 

  1171. 					break;
    1172. 

  1172. 				case TAG_GPS_GPSAreaInformation: /* Name of GPS area                       GPSAreaInformation  28     */
    1173. 

  1173. 					$this->ImageInfo['h']["GPSAreaInformation"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1174. 

  1174. 					break;
    1175. 

  1175. 				case TAG_GPS_GPSDateStamp: /* GPS date                               GPSDateStamp        29     */
    1176. 

  1176. 					$this->ImageInfo['h']["GPSDateStamp"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1177. 

  1177. 					break;
    1178. 

  1178. 				case TAG_GPS_GPSDifferential: /* GPS differential correction            GPSDifferential     30     */
    1179. 

  1179. 					$this->ImageInfo['h']["GPSDifferential"] = $this->string_format(substr($ValuePtr,0,$ByteCount));
    1180. 

  1180. 					break;
    1181. 

  1181. 

  1182. 				case TAG_AUDIO_MU_LAW:
    1183. 

  1183. 					$this->ImageInfo['h']["AudioMuLaw"] = $this->ConvertAnyFormat($ValuePtr, $Format);
    1184. 

  1184. 					break;
    1185. 

  1185. 				case TAG_AUDIO_IMA_ADPCM_DESC: //  IMA-ADPCM Audio File Description Example - 40
    1186. 

  1186. 					$this->ImageInfo['h']["AudioIMA-ADPCM-DESC"] = $this->ConvertAnyFormat($ValuePtr, $Format);
    1187. 

  1187. 					break;
    1188. 

  1188. 				case TAG_AUDIO_MU_LAW_DESC: //  µ-Law Audio File Description Sample - 50
    1189. 

  1189. 					$this->ImageInfo['h']["AudioMuLawDesc"] = $this->ConvertAnyFormat($ValuePtr, $Format);
    1190. 

  1190. 					break;
    1191. 

  1191. 

  1192. 				case TAG_EXPOSURE_INDEX:
    1193. 

  1193. 					$tmp = $this->ConvertAnyFormat($ValuePtr, $Format);
    1194. 

  1194. 					$this->ImageInfo['h']["ExposureIndex"] = sprintf("%4.2f (%d/%d)",(double)$tmp[0],$tmp[1][0],$tmp[1][1]);;
    1195. 

  1195. 					break;
    1196. 

  1196. 

  1197.                 case TAG_SENSING_METHOD:
    1198. 

  1198.                         $tmp = $this->ConvertAnyFormat($ValuePtr, $Format);
    1199. 

  1199.                         $tmpArr = array("1"=…
    1200.

Large files files are truncated, but you can click here to view the full file