splitbrain /
dokuwiki
Complex classes like JpegMeta often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use JpegMeta, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 42 | class JpegMeta { |
||
| 43 | var $_fileName; |
||
| 44 | var $_fp = null; |
||
| 45 | var $_fpout = null; |
||
| 46 | var $_type = 'unknown'; |
||
| 47 | |||
| 48 | var $_markers; |
||
| 49 | var $_info; |
||
| 50 | |||
| 51 | |||
| 52 | /** |
||
| 53 | * Constructor |
||
| 54 | * |
||
| 55 | * @author Sebastian Delmont <[email protected]> |
||
| 56 | */ |
||
| 57 | function __construct($fileName) { |
||
|
|
|||
| 58 | |||
| 59 | $this->_fileName = $fileName; |
||
| 60 | |||
| 61 | $this->_fp = null; |
||
| 62 | $this->_type = 'unknown'; |
||
| 63 | |||
| 64 | unset($this->_info); |
||
| 65 | unset($this->_markers); |
||
| 66 | } |
||
| 67 | |||
| 68 | /** |
||
| 69 | * Returns all gathered info as multidim array |
||
| 70 | * |
||
| 71 | * @author Sebastian Delmont <[email protected]> |
||
| 72 | */ |
||
| 73 | function & getRawInfo() { |
||
| 74 | $this->_parseAll(); |
||
| 75 | |||
| 76 | if ($this->_markers == null) { |
||
| 77 | return false; |
||
| 78 | } |
||
| 79 | |||
| 80 | return $this->_info; |
||
| 81 | } |
||
| 82 | |||
| 83 | /** |
||
| 84 | * Returns basic image info |
||
| 85 | * |
||
| 86 | * @author Sebastian Delmont <[email protected]> |
||
| 87 | */ |
||
| 88 | function & getBasicInfo() { |
||
| 89 | $this->_parseAll(); |
||
| 90 | |||
| 91 | $info = array(); |
||
| 92 | |||
| 93 | if ($this->_markers == null) { |
||
| 94 | return false; |
||
| 95 | } |
||
| 96 | |||
| 97 | $info['Name'] = $this->_info['file']['Name']; |
||
| 98 | if (isset($this->_info['file']['Url'])) { |
||
| 99 | $info['Url'] = $this->_info['file']['Url']; |
||
| 100 | $info['NiceSize'] = "???KB"; |
||
| 101 | } else { |
||
| 102 | $info['Size'] = $this->_info['file']['Size']; |
||
| 103 | $info['NiceSize'] = $this->_info['file']['NiceSize']; |
||
| 104 | } |
||
| 105 | |||
| 106 | if (@isset($this->_info['sof']['Format'])) { |
||
| 107 | $info['Format'] = $this->_info['sof']['Format'] . " JPEG"; |
||
| 108 | } else { |
||
| 109 | $info['Format'] = $this->_info['sof']['Format'] . " JPEG"; |
||
| 110 | } |
||
| 111 | |||
| 112 | if (@isset($this->_info['sof']['ColorChannels'])) { |
||
| 113 | $info['ColorMode'] = ($this->_info['sof']['ColorChannels'] > 1) ? "Color" : "B&W"; |
||
| 114 | } |
||
| 115 | |||
| 116 | $info['Width'] = $this->getWidth(); |
||
| 117 | $info['Height'] = $this->getHeight(); |
||
| 118 | $info['DimStr'] = $this->getDimStr(); |
||
| 119 | |||
| 120 | $dates = $this->getDates(); |
||
| 121 | |||
| 122 | $info['DateTime'] = $dates['EarliestTime']; |
||
| 123 | $info['DateTimeStr'] = $dates['EarliestTimeStr']; |
||
| 124 | |||
| 125 | $info['HasThumbnail'] = $this->hasThumbnail(); |
||
| 126 | |||
| 127 | return $info; |
||
| 128 | } |
||
| 129 | |||
| 130 | |||
| 131 | /** |
||
| 132 | * Convinience function to access nearly all available Data |
||
| 133 | * through one function |
||
| 134 | * |
||
| 135 | * @author Andreas Gohr <[email protected]> |
||
| 136 | * |
||
| 137 | * @param array|string $fields field name or array with field names |
||
| 138 | * @return bool|string |
||
| 139 | */ |
||
| 140 | function getField($fields) { |
||
| 141 | if(!is_array($fields)) $fields = array($fields); |
||
| 142 | $info = false; |
||
| 143 | foreach($fields as $field){ |
||
| 144 | if(strtolower(substr($field,0,5)) == 'iptc.'){ |
||
| 145 | $info = $this->getIPTCField(substr($field,5)); |
||
| 146 | }elseif(strtolower(substr($field,0,5)) == 'exif.'){ |
||
| 147 | $info = $this->getExifField(substr($field,5)); |
||
| 148 | }elseif(strtolower(substr($field,0,4)) == 'xmp.'){ |
||
| 149 | $info = $this->getXmpField(substr($field,4)); |
||
| 150 | }elseif(strtolower(substr($field,0,5)) == 'file.'){ |
||
| 151 | $info = $this->getFileField(substr($field,5)); |
||
| 152 | }elseif(strtolower(substr($field,0,5)) == 'date.'){ |
||
| 153 | $info = $this->getDateField(substr($field,5)); |
||
| 154 | }elseif(strtolower($field) == 'simple.camera'){ |
||
| 155 | $info = $this->getCamera(); |
||
| 156 | }elseif(strtolower($field) == 'simple.raw'){ |
||
| 157 | return $this->getRawInfo(); |
||
| 158 | }elseif(strtolower($field) == 'simple.title'){ |
||
| 159 | $info = $this->getTitle(); |
||
| 160 | }elseif(strtolower($field) == 'simple.shutterspeed'){ |
||
| 161 | $info = $this->getShutterSpeed(); |
||
| 162 | }else{ |
||
| 163 | $info = $this->getExifField($field); |
||
| 164 | } |
||
| 165 | if($info != false) break; |
||
| 166 | } |
||
| 167 | |||
| 168 | if($info === false) $info = ''; |
||
| 169 | if(is_array($info)){ |
||
| 170 | if(isset($info['val'])){ |
||
| 171 | $info = $info['val']; |
||
| 172 | }else{ |
||
| 173 | $info = join(', ',$info); |
||
| 174 | } |
||
| 175 | } |
||
| 176 | return trim($info); |
||
| 177 | } |
||
| 178 | |||
| 179 | /** |
||
| 180 | * Convinience function to set nearly all available Data |
||
| 181 | * through one function |
||
| 182 | * |
||
| 183 | * @author Andreas Gohr <[email protected]> |
||
| 184 | * |
||
| 185 | * @param string $field field name |
||
| 186 | * @param string $value |
||
| 187 | * @return bool success or fail |
||
| 188 | */ |
||
| 189 | function setField($field, $value) { |
||
| 190 | if(strtolower(substr($field,0,5)) == 'iptc.'){ |
||
| 191 | return $this->setIPTCField(substr($field,5),$value); |
||
| 192 | }elseif(strtolower(substr($field,0,5)) == 'exif.'){ |
||
| 193 | return $this->setExifField(substr($field,5),$value); |
||
| 194 | }else{ |
||
| 195 | return $this->setExifField($field,$value); |
||
| 196 | } |
||
| 197 | } |
||
| 198 | |||
| 199 | /** |
||
| 200 | * Convinience function to delete nearly all available Data |
||
| 201 | * through one function |
||
| 202 | * |
||
| 203 | * @author Andreas Gohr <[email protected]> |
||
| 204 | * |
||
| 205 | * @param string $field field name |
||
| 206 | * @return bool |
||
| 207 | */ |
||
| 208 | function deleteField($field) { |
||
| 209 | if(strtolower(substr($field,0,5)) == 'iptc.'){ |
||
| 210 | return $this->deleteIPTCField(substr($field,5)); |
||
| 211 | }elseif(strtolower(substr($field,0,5)) == 'exif.'){ |
||
| 212 | return $this->deleteExifField(substr($field,5)); |
||
| 213 | }else{ |
||
| 214 | return $this->deleteExifField($field); |
||
| 215 | } |
||
| 216 | } |
||
| 217 | |||
| 218 | /** |
||
| 219 | * Return a date field |
||
| 220 | * |
||
| 221 | * @author Andreas Gohr <[email protected]> |
||
| 222 | * |
||
| 223 | * @param string $field |
||
| 224 | * @return false|string |
||
| 225 | */ |
||
| 226 | function getDateField($field) { |
||
| 227 | if (!isset($this->_info['dates'])) { |
||
| 228 | $this->_info['dates'] = $this->getDates(); |
||
| 229 | } |
||
| 230 | |||
| 231 | if (isset($this->_info['dates'][$field])) { |
||
| 232 | return $this->_info['dates'][$field]; |
||
| 233 | } |
||
| 234 | |||
| 235 | return false; |
||
| 236 | } |
||
| 237 | |||
| 238 | /** |
||
| 239 | * Return a file info field |
||
| 240 | * |
||
| 241 | * @author Andreas Gohr <[email protected]> |
||
| 242 | * |
||
| 243 | * @param string $field field name |
||
| 244 | * @return false|string |
||
| 245 | */ |
||
| 246 | function getFileField($field) { |
||
| 247 | if (!isset($this->_info['file'])) { |
||
| 248 | $this->_parseFileInfo(); |
||
| 249 | } |
||
| 250 | |||
| 251 | if (isset($this->_info['file'][$field])) { |
||
| 252 | return $this->_info['file'][$field]; |
||
| 253 | } |
||
| 254 | |||
| 255 | return false; |
||
| 256 | } |
||
| 257 | |||
| 258 | /** |
||
| 259 | * Return the camera info (Maker and Model) |
||
| 260 | * |
||
| 261 | * @author Andreas Gohr <[email protected]> |
||
| 262 | * @todo handle makernotes |
||
| 263 | * |
||
| 264 | * @return false|string |
||
| 265 | */ |
||
| 266 | function getCamera(){ |
||
| 267 | $make = $this->getField(array('Exif.Make','Exif.TIFFMake')); |
||
| 268 | $model = $this->getField(array('Exif.Model','Exif.TIFFModel')); |
||
| 269 | $cam = trim("$make $model"); |
||
| 270 | if(empty($cam)) return false; |
||
| 271 | return $cam; |
||
| 272 | } |
||
| 273 | |||
| 274 | /** |
||
| 275 | * Return shutter speed as a ratio |
||
| 276 | * |
||
| 277 | * @author Joe Lapp <[email protected]> |
||
| 278 | * |
||
| 279 | * @return string |
||
| 280 | */ |
||
| 281 | function getShutterSpeed() { |
||
| 293 | |||
| 294 | /** |
||
| 295 | * Return an EXIF field |
||
| 296 | * |
||
| 297 | * @author Sebastian Delmont <[email protected]> |
||
| 298 | * |
||
| 299 | * @param string $field field name |
||
| 300 | * @return false|string |
||
| 301 | */ |
||
| 302 | function getExifField($field) { |
||
| 317 | |||
| 318 | /** |
||
| 319 | * Return an XMP field |
||
| 320 | * |
||
| 321 | * @author Hakan Sandell <[email protected]> |
||
| 322 | * |
||
| 323 | * @param string $field field name |
||
| 324 | * @return false|string |
||
| 325 | */ |
||
| 326 | function getXmpField($field) { |
||
| 341 | |||
| 342 | /** |
||
| 343 | * Return an Adobe Field |
||
| 344 | * |
||
| 345 | * @author Sebastian Delmont <[email protected]> |
||
| 346 | * |
||
| 347 | * @param string $field field name |
||
| 348 | * @return false|string |
||
| 349 | */ |
||
| 350 | function getAdobeField($field) { |
||
| 365 | |||
| 366 | /** |
||
| 367 | * Return an IPTC field |
||
| 368 | * |
||
| 369 | * @author Sebastian Delmont <[email protected]> |
||
| 370 | * |
||
| 371 | * @param string $field field name |
||
| 372 | * @return false|string |
||
| 373 | */ |
||
| 374 | function getIPTCField($field) { |
||
| 389 | |||
| 390 | /** |
||
| 391 | * Set an EXIF field |
||
| 392 | * |
||
| 393 | * @author Sebastian Delmont <[email protected]> |
||
| 394 | * @author Joe Lapp <[email protected]> |
||
| 395 | * |
||
| 396 | * @param string $field field name |
||
| 397 | * @param string $value |
||
| 398 | * @return bool |
||
| 399 | */ |
||
| 400 | function setExifField($field, $value) { |
||
| 401 | if (!isset($this->_info['exif'])) { |
||
| 402 | $this->_parseMarkerExif(); |
||
| 403 | } |
||
| 404 | |||
| 405 | if ($this->_markers == null) { |
||
| 406 | return false; |
||
| 407 | } |
||
| 408 | |||
| 409 | if ($this->_info['exif'] == false) { |
||
| 410 | $this->_info['exif'] = array(); |
||
| 411 | } |
||
| 412 | |||
| 413 | // make sure datetimes are in correct format |
||
| 414 | if(strlen($field) >= 8 && strtolower(substr($field, 0, 8)) == 'datetime') { |
||
| 415 | if(strlen($value) < 8 || $value{4} != ':' || $value{7} != ':') { |
||
| 416 | $value = date('Y:m:d H:i:s', strtotime($value)); |
||
| 417 | } |
||
| 418 | } |
||
| 419 | |||
| 420 | $this->_info['exif'][$field] = $value; |
||
| 421 | |||
| 422 | return true; |
||
| 423 | } |
||
| 424 | |||
| 425 | /** |
||
| 426 | * Set an Adobe Field |
||
| 427 | * |
||
| 428 | * @author Sebastian Delmont <[email protected]> |
||
| 429 | * |
||
| 430 | * @param string $field field name |
||
| 431 | * @param string $value |
||
| 432 | * @return bool |
||
| 433 | */ |
||
| 434 | function setAdobeField($field, $value) { |
||
| 451 | |||
| 452 | /** |
||
| 453 | * Calculates the multiplier needed to resize the image to the given |
||
| 454 | * dimensions |
||
| 455 | * |
||
| 456 | * @author Andreas Gohr <[email protected]> |
||
| 457 | * |
||
| 458 | * @param int $maxwidth |
||
| 459 | * @param int $maxheight |
||
| 460 | * @return float|int |
||
| 461 | */ |
||
| 462 | function getResizeRatio($maxwidth,$maxheight=0){ |
||
| 463 | if(!$maxheight) $maxheight = $maxwidth; |
||
| 464 | |||
| 465 | $w = $this->getField('File.Width'); |
||
| 466 | $h = $this->getField('File.Height'); |
||
| 467 | |||
| 468 | $ratio = 1; |
||
| 469 | if($w >= $h){ |
||
| 470 | if($w >= $maxwidth){ |
||
| 471 | $ratio = $maxwidth/$w; |
||
| 472 | }elseif($h > $maxheight){ |
||
| 473 | $ratio = $maxheight/$h; |
||
| 474 | } |
||
| 475 | }else{ |
||
| 476 | if($h >= $maxheight){ |
||
| 477 | $ratio = $maxheight/$h; |
||
| 478 | }elseif($w > $maxwidth){ |
||
| 479 | $ratio = $maxwidth/$w; |
||
| 480 | } |
||
| 481 | } |
||
| 482 | return $ratio; |
||
| 483 | } |
||
| 484 | |||
| 485 | |||
| 486 | /** |
||
| 487 | * Set an IPTC field |
||
| 488 | * |
||
| 489 | * @author Sebastian Delmont <[email protected]> |
||
| 490 | * |
||
| 491 | * @param string $field field name |
||
| 492 | * @param string $value |
||
| 493 | * @return bool |
||
| 494 | */ |
||
| 495 | function setIPTCField($field, $value) { |
||
| 512 | |||
| 513 | /** |
||
| 514 | * Delete an EXIF field |
||
| 515 | * |
||
| 516 | * @author Sebastian Delmont <[email protected]> |
||
| 517 | * |
||
| 518 | * @param string $field field name |
||
| 519 | * @return bool |
||
| 520 | */ |
||
| 521 | function deleteExifField($field) { |
||
| 536 | |||
| 537 | /** |
||
| 538 | * Delete an Adobe field |
||
| 539 | * |
||
| 540 | * @author Sebastian Delmont <[email protected]> |
||
| 541 | * |
||
| 542 | * @param string $field field name |
||
| 543 | * @return bool |
||
| 544 | */ |
||
| 545 | function deleteAdobeField($field) { |
||
| 560 | |||
| 561 | /** |
||
| 562 | * Delete an IPTC field |
||
| 563 | * |
||
| 564 | * @author Sebastian Delmont <[email protected]> |
||
| 565 | * |
||
| 566 | * @param string $field field name |
||
| 567 | * @return bool |
||
| 568 | */ |
||
| 569 | function deleteIPTCField($field) { |
||
| 584 | |||
| 585 | /** |
||
| 586 | * Get the image's title, tries various fields |
||
| 587 | * |
||
| 588 | * @param int $max maximum number chars (keeps words) |
||
| 589 | * @return false|string |
||
| 590 | * |
||
| 591 | * @author Andreas Gohr <[email protected]> |
||
| 592 | */ |
||
| 593 | function getTitle($max=80){ |
||
| 611 | |||
| 612 | /** |
||
| 613 | * Gather various date fields |
||
| 614 | * |
||
| 615 | * @author Sebastian Delmont <[email protected]> |
||
| 616 | * |
||
| 617 | * @return array|bool |
||
| 618 | */ |
||
| 619 | function getDates() { |
||
| 749 | |||
| 750 | /** |
||
| 751 | * Get the image width, tries various fields |
||
| 752 | * |
||
| 753 | * @author Sebastian Delmont <[email protected]> |
||
| 754 | * |
||
| 755 | * @return false|string |
||
| 756 | */ |
||
| 757 | function getWidth() { |
||
| 758 | if (!isset($this->_info['sof'])) { |
||
| 759 | $this->_parseMarkerSOF(); |
||
| 760 | } |
||
| 761 | |||
| 762 | if ($this->_markers == null) { |
||
| 763 | return false; |
||
| 764 | } |
||
| 765 | |||
| 766 | if (isset($this->_info['sof']['ImageWidth'])) { |
||
| 767 | return $this->_info['sof']['ImageWidth']; |
||
| 768 | } |
||
| 769 | |||
| 770 | if (!isset($this->_info['exif'])) { |
||
| 771 | $this->_parseMarkerExif(); |
||
| 772 | } |
||
| 773 | |||
| 774 | if (isset($this->_info['exif']['PixelXDimension'])) { |
||
| 775 | return $this->_info['exif']['PixelXDimension']; |
||
| 776 | } |
||
| 777 | |||
| 778 | return false; |
||
| 779 | } |
||
| 780 | |||
| 781 | /** |
||
| 782 | * Get the image height, tries various fields |
||
| 783 | * |
||
| 784 | * @author Sebastian Delmont <[email protected]> |
||
| 785 | * |
||
| 786 | * @return false|string |
||
| 787 | */ |
||
| 788 | function getHeight() { |
||
| 789 | if (!isset($this->_info['sof'])) { |
||
| 790 | $this->_parseMarkerSOF(); |
||
| 791 | } |
||
| 792 | |||
| 793 | if ($this->_markers == null) { |
||
| 794 | return false; |
||
| 795 | } |
||
| 796 | |||
| 797 | if (isset($this->_info['sof']['ImageHeight'])) { |
||
| 798 | return $this->_info['sof']['ImageHeight']; |
||
| 799 | } |
||
| 800 | |||
| 801 | if (!isset($this->_info['exif'])) { |
||
| 802 | $this->_parseMarkerExif(); |
||
| 803 | } |
||
| 804 | |||
| 805 | if (isset($this->_info['exif']['PixelYDimension'])) { |
||
| 806 | return $this->_info['exif']['PixelYDimension']; |
||
| 807 | } |
||
| 808 | |||
| 809 | return false; |
||
| 810 | } |
||
| 811 | |||
| 812 | /** |
||
| 813 | * Get an dimension string for use in img tag |
||
| 814 | * |
||
| 815 | * @author Sebastian Delmont <[email protected]> |
||
| 816 | * |
||
| 817 | * @return false|string |
||
| 818 | */ |
||
| 819 | function getDimStr() { |
||
| 820 | if ($this->_markers == null) { |
||
| 821 | return false; |
||
| 822 | } |
||
| 823 | |||
| 824 | $w = $this->getWidth(); |
||
| 825 | $h = $this->getHeight(); |
||
| 826 | |||
| 827 | return "width='" . $w . "' height='" . $h . "'"; |
||
| 828 | } |
||
| 829 | |||
| 830 | /** |
||
| 831 | * Checks for an embedded thumbnail |
||
| 832 | * |
||
| 833 | * @author Sebastian Delmont <[email protected]> |
||
| 834 | * |
||
| 835 | * @param string $which possible values: 'any', 'exif' or 'adobe' |
||
| 836 | * @return false|string |
||
| 837 | */ |
||
| 838 | function hasThumbnail($which = 'any') { |
||
| 839 | if (($which == 'any') || ($which == 'exif')) { |
||
| 840 | if (!isset($this->_info['exif'])) { |
||
| 841 | $this->_parseMarkerExif(); |
||
| 842 | } |
||
| 843 | |||
| 844 | if ($this->_markers == null) { |
||
| 845 | return false; |
||
| 846 | } |
||
| 847 | |||
| 848 | if (isset($this->_info['exif']) && is_array($this->_info['exif'])) { |
||
| 849 | if (isset($this->_info['exif']['JFIFThumbnail'])) { |
||
| 850 | return 'exif'; |
||
| 851 | } |
||
| 852 | } |
||
| 853 | } |
||
| 854 | |||
| 855 | if ($which == 'adobe') { |
||
| 856 | if (!isset($this->_info['adobe'])) { |
||
| 857 | $this->_parseMarkerAdobe(); |
||
| 858 | } |
||
| 859 | |||
| 860 | if ($this->_markers == null) { |
||
| 861 | return false; |
||
| 862 | } |
||
| 863 | |||
| 864 | if (isset($this->_info['adobe']) && is_array($this->_info['adobe'])) { |
||
| 865 | if (isset($this->_info['adobe']['ThumbnailData'])) { |
||
| 866 | return 'exif'; |
||
| 867 | } |
||
| 868 | } |
||
| 869 | } |
||
| 870 | |||
| 871 | return false; |
||
| 872 | } |
||
| 873 | |||
| 874 | /** |
||
| 875 | * Send embedded thumbnail to browser |
||
| 876 | * |
||
| 877 | * @author Sebastian Delmont <[email protected]> |
||
| 878 | * |
||
| 879 | * @param string $which possible values: 'any', 'exif' or 'adobe' |
||
| 880 | * @return bool |
||
| 881 | */ |
||
| 882 | function sendThumbnail($which = 'any') { |
||
| 883 | $data = null; |
||
| 884 | |||
| 885 | if (($which == 'any') || ($which == 'exif')) { |
||
| 886 | if (!isset($this->_info['exif'])) { |
||
| 887 | $this->_parseMarkerExif(); |
||
| 888 | } |
||
| 889 | |||
| 890 | if ($this->_markers == null) { |
||
| 891 | return false; |
||
| 892 | } |
||
| 893 | |||
| 894 | if (isset($this->_info['exif']) && is_array($this->_info['exif'])) { |
||
| 895 | if (isset($this->_info['exif']['JFIFThumbnail'])) { |
||
| 896 | $data =& $this->_info['exif']['JFIFThumbnail']; |
||
| 897 | } |
||
| 898 | } |
||
| 899 | } |
||
| 900 | |||
| 901 | if (($which == 'adobe') || ($data == null)){ |
||
| 902 | if (!isset($this->_info['adobe'])) { |
||
| 903 | $this->_parseMarkerAdobe(); |
||
| 904 | } |
||
| 905 | |||
| 906 | if ($this->_markers == null) { |
||
| 907 | return false; |
||
| 908 | } |
||
| 909 | |||
| 910 | if (isset($this->_info['adobe']) && is_array($this->_info['adobe'])) { |
||
| 911 | if (isset($this->_info['adobe']['ThumbnailData'])) { |
||
| 912 | $data =& $this->_info['adobe']['ThumbnailData']; |
||
| 913 | } |
||
| 914 | } |
||
| 915 | } |
||
| 916 | |||
| 917 | if ($data != null) { |
||
| 918 | header("Content-type: image/jpeg"); |
||
| 919 | echo $data; |
||
| 920 | return true; |
||
| 921 | } |
||
| 922 | |||
| 923 | return false; |
||
| 924 | } |
||
| 925 | |||
| 926 | /** |
||
| 927 | * Save changed Metadata |
||
| 928 | * |
||
| 929 | * @author Sebastian Delmont <[email protected]> |
||
| 930 | * @author Andreas Gohr <[email protected]> |
||
| 931 | * |
||
| 932 | * @param string $fileName file name or empty string for a random name |
||
| 933 | * @return bool |
||
| 934 | */ |
||
| 935 | function save($fileName = "") { |
||
| 936 | if ($fileName == "") { |
||
| 937 | $tmpName = tempnam(dirname($this->_fileName),'_metatemp_'); |
||
| 938 | $this->_writeJPEG($tmpName); |
||
| 939 | if (file_exists($tmpName)) { |
||
| 940 | return io_rename($tmpName, $this->_fileName); |
||
| 941 | } |
||
| 942 | } else { |
||
| 943 | return $this->_writeJPEG($fileName); |
||
| 944 | } |
||
| 945 | return false; |
||
| 946 | } |
||
| 947 | |||
| 948 | /*************************************************************/ |
||
| 949 | /* PRIVATE FUNCTIONS (Internal Use Only!) */ |
||
| 950 | /*************************************************************/ |
||
| 951 | |||
| 952 | /*************************************************************/ |
||
| 953 | function _dispose($fileName = "") { |
||
| 954 | $this->_fileName = $fileName; |
||
| 955 | |||
| 956 | $this->_fp = null; |
||
| 957 | $this->_type = 'unknown'; |
||
| 958 | |||
| 959 | unset($this->_markers); |
||
| 960 | unset($this->_info); |
||
| 961 | } |
||
| 962 | |||
| 963 | /*************************************************************/ |
||
| 964 | function _readJPEG() { |
||
| 965 | unset($this->_markers); |
||
| 966 | //unset($this->_info); |
||
| 967 | $this->_markers = array(); |
||
| 968 | //$this->_info = array(); |
||
| 969 | |||
| 970 | $this->_fp = @fopen($this->_fileName, 'rb'); |
||
| 971 | if ($this->_fp) { |
||
| 972 | if (file_exists($this->_fileName)) { |
||
| 973 | $this->_type = 'file'; |
||
| 974 | } |
||
| 975 | else { |
||
| 976 | $this->_type = 'url'; |
||
| 977 | } |
||
| 978 | } else { |
||
| 979 | $this->_fp = null; |
||
| 980 | return false; // ERROR: Can't open file |
||
| 981 | } |
||
| 982 | |||
| 983 | // Check for the JPEG signature |
||
| 984 | $c1 = ord(fgetc($this->_fp)); |
||
| 985 | $c2 = ord(fgetc($this->_fp)); |
||
| 986 | |||
| 987 | if ($c1 != 0xFF || $c2 != 0xD8) { // (0xFF + SOI) |
||
| 988 | $this->_markers = null; |
||
| 989 | return false; // ERROR: File is not a JPEG |
||
| 990 | } |
||
| 991 | |||
| 992 | $count = 0; |
||
| 993 | |||
| 994 | $done = false; |
||
| 995 | $ok = true; |
||
| 996 | |||
| 997 | while (!$done) { |
||
| 998 | $capture = false; |
||
| 999 | |||
| 1000 | // First, skip any non 0xFF bytes |
||
| 1001 | $discarded = 0; |
||
| 1002 | $c = ord(fgetc($this->_fp)); |
||
| 1003 | while (!feof($this->_fp) && ($c != 0xFF)) { |
||
| 1004 | $discarded++; |
||
| 1005 | $c = ord(fgetc($this->_fp)); |
||
| 1006 | } |
||
| 1007 | // Then skip all 0xFF until the marker byte |
||
| 1008 | do { |
||
| 1009 | $marker = ord(fgetc($this->_fp)); |
||
| 1010 | } while (!feof($this->_fp) && ($marker == 0xFF)); |
||
| 1011 | |||
| 1012 | if (feof($this->_fp)) { |
||
| 1013 | return false; // ERROR: Unexpected EOF |
||
| 1014 | } |
||
| 1015 | if ($discarded != 0) { |
||
| 1016 | return false; // ERROR: Extraneous data |
||
| 1017 | } |
||
| 1018 | |||
| 1019 | $length = ord(fgetc($this->_fp)) * 256 + ord(fgetc($this->_fp)); |
||
| 1020 | if (feof($this->_fp)) { |
||
| 1021 | return false; // ERROR: Unexpected EOF |
||
| 1022 | } |
||
| 1023 | if ($length < 2) { |
||
| 1024 | return false; // ERROR: Extraneous data |
||
| 1025 | } |
||
| 1026 | $length = $length - 2; // The length we got counts itself |
||
| 1027 | |||
| 1028 | switch ($marker) { |
||
| 1029 | case 0xC0: // SOF0 |
||
| 1030 | case 0xC1: // SOF1 |
||
| 1031 | case 0xC2: // SOF2 |
||
| 1032 | case 0xC9: // SOF9 |
||
| 1033 | case 0xE0: // APP0: JFIF data |
||
| 1034 | case 0xE1: // APP1: EXIF or XMP data |
||
| 1035 | case 0xED: // APP13: IPTC / Photoshop data |
||
| 1036 | $capture = true; |
||
| 1037 | break; |
||
| 1038 | case 0xDA: // SOS: Start of scan... the image itself and the last block on the file |
||
| 1039 | $capture = false; |
||
| 1040 | $length = -1; // This field has no length... it includes all data until EOF |
||
| 1041 | $done = true; |
||
| 1042 | break; |
||
| 1043 | default: |
||
| 1044 | $capture = true;//false; |
||
| 1045 | break; |
||
| 1046 | } |
||
| 1047 | |||
| 1048 | $this->_markers[$count] = array(); |
||
| 1049 | $this->_markers[$count]['marker'] = $marker; |
||
| 1050 | $this->_markers[$count]['length'] = $length; |
||
| 1051 | |||
| 1052 | if ($capture) { |
||
| 1053 | if ($length) |
||
| 1054 | $this->_markers[$count]['data'] = fread($this->_fp, $length); |
||
| 1055 | else |
||
| 1056 | $this->_markers[$count]['data'] = ""; |
||
| 1057 | } |
||
| 1058 | elseif (!$done) { |
||
| 1059 | $result = @fseek($this->_fp, $length, SEEK_CUR); |
||
| 1060 | // fseek doesn't seem to like HTTP 'files', but fgetc has no problem |
||
| 1061 | if (!($result === 0)) { |
||
| 1062 | for ($i = 0; $i < $length; $i++) { |
||
| 1063 | fgetc($this->_fp); |
||
| 1064 | } |
||
| 1065 | } |
||
| 1066 | } |
||
| 1067 | $count++; |
||
| 1068 | } |
||
| 1069 | |||
| 1070 | if ($this->_fp) { |
||
| 1071 | fclose($this->_fp); |
||
| 1072 | $this->_fp = null; |
||
| 1073 | } |
||
| 1074 | |||
| 1075 | return $ok; |
||
| 1076 | } |
||
| 1077 | |||
| 1078 | /*************************************************************/ |
||
| 1079 | function _parseAll() { |
||
| 1080 | if (!isset($this->_info['file'])) { |
||
| 1081 | $this->_parseFileInfo(); |
||
| 1082 | } |
||
| 1083 | if (!isset($this->_markers)) { |
||
| 1084 | $this->_readJPEG(); |
||
| 1085 | } |
||
| 1086 | |||
| 1087 | if ($this->_markers == null) { |
||
| 1088 | return false; |
||
| 1089 | } |
||
| 1090 | |||
| 1091 | if (!isset($this->_info['jfif'])) { |
||
| 1092 | $this->_parseMarkerJFIF(); |
||
| 1093 | } |
||
| 1094 | if (!isset($this->_info['jpeg'])) { |
||
| 1095 | $this->_parseMarkerSOF(); |
||
| 1096 | } |
||
| 1097 | if (!isset($this->_info['exif'])) { |
||
| 1098 | $this->_parseMarkerExif(); |
||
| 1099 | } |
||
| 1100 | if (!isset($this->_info['xmp'])) { |
||
| 1101 | $this->_parseMarkerXmp(); |
||
| 1102 | } |
||
| 1103 | if (!isset($this->_info['adobe'])) { |
||
| 1104 | $this->_parseMarkerAdobe(); |
||
| 1105 | } |
||
| 1106 | } |
||
| 1107 | |||
| 1108 | /*************************************************************/ |
||
| 1109 | |||
| 1110 | /** |
||
| 1111 | * @param string $outputName |
||
| 1112 | */ |
||
| 1113 | function _writeJPEG($outputName) { |
||
| 1114 | $this->_parseAll(); |
||
| 1115 | |||
| 1116 | $wroteEXIF = false; |
||
| 1117 | $wroteAdobe = false; |
||
| 1118 | |||
| 1119 | $this->_fp = @fopen($this->_fileName, 'r'); |
||
| 1120 | if ($this->_fp) { |
||
| 1121 | if (file_exists($this->_fileName)) { |
||
| 1122 | $this->_type = 'file'; |
||
| 1123 | } |
||
| 1124 | else { |
||
| 1125 | $this->_type = 'url'; |
||
| 1126 | } |
||
| 1127 | } else { |
||
| 1128 | $this->_fp = null; |
||
| 1129 | return false; // ERROR: Can't open file |
||
| 1130 | } |
||
| 1131 | |||
| 1132 | $this->_fpout = fopen($outputName, 'wb'); |
||
| 1133 | if (!$this->_fpout) { |
||
| 1134 | $this->_fpout = null; |
||
| 1135 | fclose($this->_fp); |
||
| 1136 | $this->_fp = null; |
||
| 1137 | return false; // ERROR: Can't open output file |
||
| 1138 | } |
||
| 1139 | |||
| 1140 | // Check for the JPEG signature |
||
| 1141 | $c1 = ord(fgetc($this->_fp)); |
||
| 1142 | $c2 = ord(fgetc($this->_fp)); |
||
| 1143 | |||
| 1144 | if ($c1 != 0xFF || $c2 != 0xD8) { // (0xFF + SOI) |
||
| 1145 | return false; // ERROR: File is not a JPEG |
||
| 1146 | } |
||
| 1147 | |||
| 1148 | fputs($this->_fpout, chr(0xFF), 1); |
||
| 1149 | fputs($this->_fpout, chr(0xD8), 1); // (0xFF + SOI) |
||
| 1150 | |||
| 1151 | $count = 0; |
||
| 1152 | |||
| 1153 | $done = false; |
||
| 1154 | $ok = true; |
||
| 1155 | |||
| 1156 | while (!$done) { |
||
| 1157 | // First, skip any non 0xFF bytes |
||
| 1158 | $discarded = 0; |
||
| 1159 | $c = ord(fgetc($this->_fp)); |
||
| 1160 | while (!feof($this->_fp) && ($c != 0xFF)) { |
||
| 1161 | $discarded++; |
||
| 1162 | $c = ord(fgetc($this->_fp)); |
||
| 1163 | } |
||
| 1164 | // Then skip all 0xFF until the marker byte |
||
| 1165 | do { |
||
| 1166 | $marker = ord(fgetc($this->_fp)); |
||
| 1167 | } while (!feof($this->_fp) && ($marker == 0xFF)); |
||
| 1168 | |||
| 1169 | if (feof($this->_fp)) { |
||
| 1170 | $ok = false; |
||
| 1171 | break; // ERROR: Unexpected EOF |
||
| 1172 | } |
||
| 1173 | if ($discarded != 0) { |
||
| 1174 | $ok = false; |
||
| 1175 | break; // ERROR: Extraneous data |
||
| 1176 | } |
||
| 1177 | |||
| 1178 | $length = ord(fgetc($this->_fp)) * 256 + ord(fgetc($this->_fp)); |
||
| 1179 | if (feof($this->_fp)) { |
||
| 1180 | $ok = false; |
||
| 1181 | break; // ERROR: Unexpected EOF |
||
| 1182 | } |
||
| 1183 | if ($length < 2) { |
||
| 1184 | $ok = false; |
||
| 1185 | break; // ERROR: Extraneous data |
||
| 1186 | } |
||
| 1187 | $length = $length - 2; // The length we got counts itself |
||
| 1188 | |||
| 1189 | unset($data); |
||
| 1190 | if ($marker == 0xE1) { // APP1: EXIF data |
||
| 1191 | $data =& $this->_createMarkerEXIF(); |
||
| 1192 | $wroteEXIF = true; |
||
| 1193 | } |
||
| 1194 | elseif ($marker == 0xED) { // APP13: IPTC / Photoshop data |
||
| 1195 | $data =& $this->_createMarkerAdobe(); |
||
| 1196 | $wroteAdobe = true; |
||
| 1197 | } |
||
| 1198 | elseif ($marker == 0xDA) { // SOS: Start of scan... the image itself and the last block on the file |
||
| 1199 | $done = true; |
||
| 1200 | } |
||
| 1201 | |||
| 1202 | if (!$wroteEXIF && (($marker < 0xE0) || ($marker > 0xEF))) { |
||
| 1203 | if (isset($this->_info['exif']) && is_array($this->_info['exif'])) { |
||
| 1204 | $exif =& $this->_createMarkerEXIF(); |
||
| 1205 | $this->_writeJPEGMarker(0xE1, strlen($exif), $exif, 0); |
||
| 1206 | unset($exif); |
||
| 1207 | } |
||
| 1208 | $wroteEXIF = true; |
||
| 1209 | } |
||
| 1210 | |||
| 1211 | if (!$wroteAdobe && (($marker < 0xE0) || ($marker > 0xEF))) { |
||
| 1212 | if ((isset($this->_info['adobe']) && is_array($this->_info['adobe'])) |
||
| 1213 | || (isset($this->_info['iptc']) && is_array($this->_info['iptc']))) { |
||
| 1214 | $adobe =& $this->_createMarkerAdobe(); |
||
| 1215 | $this->_writeJPEGMarker(0xED, strlen($adobe), $adobe, 0); |
||
| 1216 | unset($adobe); |
||
| 1217 | } |
||
| 1218 | $wroteAdobe = true; |
||
| 1219 | } |
||
| 1220 | |||
| 1221 | $origLength = $length; |
||
| 1222 | if (isset($data)) { |
||
| 1223 | $length = strlen($data); |
||
| 1224 | } |
||
| 1225 | |||
| 1226 | if ($marker != -1) { |
||
| 1227 | $this->_writeJPEGMarker($marker, $length, $data, $origLength); |
||
| 1228 | } |
||
| 1229 | } |
||
| 1230 | |||
| 1231 | if ($this->_fp) { |
||
| 1232 | fclose($this->_fp); |
||
| 1233 | $this->_fp = null; |
||
| 1234 | } |
||
| 1235 | |||
| 1236 | if ($this->_fpout) { |
||
| 1237 | fclose($this->_fpout); |
||
| 1238 | $this->_fpout = null; |
||
| 1239 | } |
||
| 1240 | |||
| 1241 | return $ok; |
||
| 1242 | } |
||
| 1243 | |||
| 1244 | /*************************************************************/ |
||
| 1245 | |||
| 1246 | /** |
||
| 1247 | * @param integer $marker |
||
| 1248 | * @param integer $length |
||
| 1249 | * @param integer $origLength |
||
| 1250 | */ |
||
| 1251 | function _writeJPEGMarker($marker, $length, &$data, $origLength) { |
||
| 1252 | if ($length <= 0) { |
||
| 1253 | return false; |
||
| 1254 | } |
||
| 1255 | |||
| 1256 | fputs($this->_fpout, chr(0xFF), 1); |
||
| 1257 | fputs($this->_fpout, chr($marker), 1); |
||
| 1258 | fputs($this->_fpout, chr((($length + 2) & 0x0000FF00) >> 8), 1); |
||
| 1259 | fputs($this->_fpout, chr((($length + 2) & 0x000000FF) >> 0), 1); |
||
| 1260 | |||
| 1261 | if (isset($data)) { |
||
| 1262 | // Copy the generated data |
||
| 1263 | fputs($this->_fpout, $data, $length); |
||
| 1264 | |||
| 1265 | if ($origLength > 0) { // Skip the original data |
||
| 1266 | $result = @fseek($this->_fp, $origLength, SEEK_CUR); |
||
| 1267 | // fseek doesn't seem to like HTTP 'files', but fgetc has no problem |
||
| 1268 | if ($result != 0) { |
||
| 1269 | for ($i = 0; $i < $origLength; $i++) { |
||
| 1270 | fgetc($this->_fp); |
||
| 1271 | } |
||
| 1272 | } |
||
| 1273 | } |
||
| 1274 | } else { |
||
| 1275 | if ($marker == 0xDA) { // Copy until EOF |
||
| 1276 | while (!feof($this->_fp)) { |
||
| 1277 | $data = fread($this->_fp, 1024 * 16); |
||
| 1278 | fputs($this->_fpout, $data, strlen($data)); |
||
| 1279 | } |
||
| 1280 | } else { // Copy only $length bytes |
||
| 1281 | $data = @fread($this->_fp, $length); |
||
| 1282 | fputs($this->_fpout, $data, $length); |
||
| 1283 | } |
||
| 1284 | } |
||
| 1285 | |||
| 1286 | return true; |
||
| 1287 | } |
||
| 1288 | |||
| 1289 | /** |
||
| 1290 | * Gets basic info from the file - should work with non-JPEGs |
||
| 1291 | * |
||
| 1292 | * @author Sebastian Delmont <[email protected]> |
||
| 1293 | * @author Andreas Gohr <[email protected]> |
||
| 1294 | */ |
||
| 1295 | function _parseFileInfo() { |
||
| 1296 | if (file_exists($this->_fileName) && is_file($this->_fileName)) { |
||
| 1297 | $this->_info['file'] = array(); |
||
| 1298 | $this->_info['file']['Name'] = utf8_decodeFN(utf8_basename($this->_fileName)); |
||
| 1299 | $this->_info['file']['Path'] = fullpath($this->_fileName); |
||
| 1300 | $this->_info['file']['Size'] = filesize($this->_fileName); |
||
| 1301 | if ($this->_info['file']['Size'] < 1024) { |
||
| 1302 | $this->_info['file']['NiceSize'] = $this->_info['file']['Size'] . 'B'; |
||
| 1303 | } elseif ($this->_info['file']['Size'] < (1024 * 1024)) { |
||
| 1304 | $this->_info['file']['NiceSize'] = round($this->_info['file']['Size'] / 1024) . 'KB'; |
||
| 1305 | } elseif ($this->_info['file']['Size'] < (1024 * 1024 * 1024)) { |
||
| 1306 | $this->_info['file']['NiceSize'] = round($this->_info['file']['Size'] / (1024*1024)) . 'MB'; |
||
| 1307 | } else { |
||
| 1308 | $this->_info['file']['NiceSize'] = $this->_info['file']['Size'] . 'B'; |
||
| 1309 | } |
||
| 1310 | $this->_info['file']['UnixTime'] = filemtime($this->_fileName); |
||
| 1311 | |||
| 1312 | // get image size directly from file |
||
| 1313 | $size = getimagesize($this->_fileName); |
||
| 1314 | $this->_info['file']['Width'] = $size[0]; |
||
| 1315 | $this->_info['file']['Height'] = $size[1]; |
||
| 1316 | // set mime types and formats |
||
| 1317 | // http://www.php.net/manual/en/function.getimagesize.php |
||
| 1318 | // http://www.php.net/manual/en/function.image-type-to-mime-type.php |
||
| 1319 | switch ($size[2]){ |
||
| 1320 | case 1: |
||
| 1321 | $this->_info['file']['Mime'] = 'image/gif'; |
||
| 1322 | $this->_info['file']['Format'] = 'GIF'; |
||
| 1323 | break; |
||
| 1324 | case 2: |
||
| 1325 | $this->_info['file']['Mime'] = 'image/jpeg'; |
||
| 1326 | $this->_info['file']['Format'] = 'JPEG'; |
||
| 1327 | break; |
||
| 1328 | case 3: |
||
| 1329 | $this->_info['file']['Mime'] = 'image/png'; |
||
| 1330 | $this->_info['file']['Format'] = 'PNG'; |
||
| 1331 | break; |
||
| 1332 | case 4: |
||
| 1333 | $this->_info['file']['Mime'] = 'application/x-shockwave-flash'; |
||
| 1334 | $this->_info['file']['Format'] = 'SWF'; |
||
| 1335 | break; |
||
| 1336 | case 5: |
||
| 1337 | $this->_info['file']['Mime'] = 'image/psd'; |
||
| 1338 | $this->_info['file']['Format'] = 'PSD'; |
||
| 1339 | break; |
||
| 1340 | case 6: |
||
| 1341 | $this->_info['file']['Mime'] = 'image/bmp'; |
||
| 1342 | $this->_info['file']['Format'] = 'BMP'; |
||
| 1343 | break; |
||
| 1344 | case 7: |
||
| 1345 | $this->_info['file']['Mime'] = 'image/tiff'; |
||
| 1346 | $this->_info['file']['Format'] = 'TIFF (Intel)'; |
||
| 1347 | break; |
||
| 1348 | case 8: |
||
| 1349 | $this->_info['file']['Mime'] = 'image/tiff'; |
||
| 1350 | $this->_info['file']['Format'] = 'TIFF (Motorola)'; |
||
| 1351 | break; |
||
| 1352 | case 9: |
||
| 1353 | $this->_info['file']['Mime'] = 'application/octet-stream'; |
||
| 1354 | $this->_info['file']['Format'] = 'JPC'; |
||
| 1355 | break; |
||
| 1356 | case 10: |
||
| 1357 | $this->_info['file']['Mime'] = 'image/jp2'; |
||
| 1358 | $this->_info['file']['Format'] = 'JP2'; |
||
| 1359 | break; |
||
| 1360 | case 11: |
||
| 1361 | $this->_info['file']['Mime'] = 'application/octet-stream'; |
||
| 1362 | $this->_info['file']['Format'] = 'JPX'; |
||
| 1363 | break; |
||
| 1364 | case 12: |
||
| 1365 | $this->_info['file']['Mime'] = 'application/octet-stream'; |
||
| 1366 | $this->_info['file']['Format'] = 'JB2'; |
||
| 1367 | break; |
||
| 1368 | case 13: |
||
| 1369 | $this->_info['file']['Mime'] = 'application/x-shockwave-flash'; |
||
| 1370 | $this->_info['file']['Format'] = 'SWC'; |
||
| 1371 | break; |
||
| 1372 | case 14: |
||
| 1373 | $this->_info['file']['Mime'] = 'image/iff'; |
||
| 1374 | $this->_info['file']['Format'] = 'IFF'; |
||
| 1375 | break; |
||
| 1376 | case 15: |
||
| 1377 | $this->_info['file']['Mime'] = 'image/vnd.wap.wbmp'; |
||
| 1378 | $this->_info['file']['Format'] = 'WBMP'; |
||
| 1379 | break; |
||
| 1380 | case 16: |
||
| 1381 | $this->_info['file']['Mime'] = 'image/xbm'; |
||
| 1382 | $this->_info['file']['Format'] = 'XBM'; |
||
| 1383 | break; |
||
| 1384 | default: |
||
| 1385 | $this->_info['file']['Mime'] = 'image/unknown'; |
||
| 1386 | } |
||
| 1387 | } else { |
||
| 1388 | $this->_info['file'] = array(); |
||
| 1389 | $this->_info['file']['Name'] = utf8_basename($this->_fileName); |
||
| 1390 | $this->_info['file']['Url'] = $this->_fileName; |
||
| 1391 | } |
||
| 1392 | |||
| 1393 | return true; |
||
| 1394 | } |
||
| 1395 | |||
| 1396 | /*************************************************************/ |
||
| 1397 | function _parseMarkerJFIF() { |
||
| 1398 | if (!isset($this->_markers)) { |
||
| 1399 | $this->_readJPEG(); |
||
| 1400 | } |
||
| 1401 | |||
| 1402 | if ($this->_markers == null) { |
||
| 1403 | return false; |
||
| 1404 | } |
||
| 1405 | |||
| 1406 | $data = null; |
||
| 1407 | $count = count($this->_markers); |
||
| 1408 | for ($i = 0; $i < $count; $i++) { |
||
| 1409 | if ($this->_markers[$i]['marker'] == 0xE0) { |
||
| 1410 | $signature = $this->_getFixedString($this->_markers[$i]['data'], 0, 4); |
||
| 1411 | if ($signature == 'JFIF') { |
||
| 1412 | $data =& $this->_markers[$i]['data']; |
||
| 1413 | break; |
||
| 1414 | } |
||
| 1415 | } |
||
| 1416 | } |
||
| 1417 | |||
| 1418 | if ($data == null) { |
||
| 1419 | $this->_info['jfif'] = false; |
||
| 1420 | return false; |
||
| 1421 | } |
||
| 1422 | |||
| 1423 | $this->_info['jfif'] = array(); |
||
| 1424 | |||
| 1425 | $vmaj = $this->_getByte($data, 5); |
||
| 1426 | $vmin = $this->_getByte($data, 6); |
||
| 1427 | |||
| 1428 | $this->_info['jfif']['Version'] = sprintf('%d.%02d', $vmaj, $vmin); |
||
| 1429 | |||
| 1430 | $units = $this->_getByte($data, 7); |
||
| 1431 | switch ($units) { |
||
| 1432 | case 0: |
||
| 1433 | $this->_info['jfif']['Units'] = 'pixels'; |
||
| 1434 | break; |
||
| 1435 | case 1: |
||
| 1436 | $this->_info['jfif']['Units'] = 'dpi'; |
||
| 1437 | break; |
||
| 1438 | case 2: |
||
| 1439 | $this->_info['jfif']['Units'] = 'dpcm'; |
||
| 1440 | break; |
||
| 1441 | default: |
||
| 1442 | $this->_info['jfif']['Units'] = 'unknown'; |
||
| 1443 | break; |
||
| 1444 | } |
||
| 1445 | |||
| 1446 | $xdens = $this->_getShort($data, 8); |
||
| 1447 | $ydens = $this->_getShort($data, 10); |
||
| 1448 | |||
| 1449 | $this->_info['jfif']['XDensity'] = $xdens; |
||
| 1450 | $this->_info['jfif']['YDensity'] = $ydens; |
||
| 1451 | |||
| 1452 | $thumbx = $this->_getByte($data, 12); |
||
| 1453 | $thumby = $this->_getByte($data, 13); |
||
| 1454 | |||
| 1455 | $this->_info['jfif']['ThumbnailWidth'] = $thumbx; |
||
| 1456 | $this->_info['jfif']['ThumbnailHeight'] = $thumby; |
||
| 1457 | |||
| 1458 | return true; |
||
| 1459 | } |
||
| 1460 | |||
| 1461 | /*************************************************************/ |
||
| 1462 | function _parseMarkerSOF() { |
||
| 1463 | if (!isset($this->_markers)) { |
||
| 1464 | $this->_readJPEG(); |
||
| 1465 | } |
||
| 1466 | |||
| 1467 | if ($this->_markers == null) { |
||
| 1468 | return false; |
||
| 1469 | } |
||
| 1470 | |||
| 1471 | $data = null; |
||
| 1472 | $count = count($this->_markers); |
||
| 1473 | for ($i = 0; $i < $count; $i++) { |
||
| 1474 | switch ($this->_markers[$i]['marker']) { |
||
| 1475 | case 0xC0: // SOF0 |
||
| 1476 | case 0xC1: // SOF1 |
||
| 1477 | case 0xC2: // SOF2 |
||
| 1478 | case 0xC9: // SOF9 |
||
| 1479 | $data =& $this->_markers[$i]['data']; |
||
| 1480 | $marker = $this->_markers[$i]['marker']; |
||
| 1481 | break; |
||
| 1482 | } |
||
| 1483 | } |
||
| 1484 | |||
| 1485 | if ($data == null) { |
||
| 1486 | $this->_info['sof'] = false; |
||
| 1487 | return false; |
||
| 1488 | } |
||
| 1489 | |||
| 1490 | $pos = 0; |
||
| 1491 | $this->_info['sof'] = array(); |
||
| 1492 | |||
| 1493 | switch ($marker) { |
||
| 1494 | case 0xC0: // SOF0 |
||
| 1495 | $format = 'Baseline'; |
||
| 1496 | break; |
||
| 1497 | case 0xC1: // SOF1 |
||
| 1498 | $format = 'Progessive'; |
||
| 1499 | break; |
||
| 1500 | case 0xC2: // SOF2 |
||
| 1501 | $format = 'Non-baseline'; |
||
| 1502 | break; |
||
| 1503 | case 0xC9: // SOF9 |
||
| 1504 | $format = 'Arithmetic'; |
||
| 1505 | break; |
||
| 1506 | default: |
||
| 1507 | return false; |
||
| 1508 | } |
||
| 1509 | |||
| 1510 | $this->_info['sof']['Format'] = $format; |
||
| 1511 | $this->_info['sof']['SamplePrecision'] = $this->_getByte($data, $pos + 0); |
||
| 1512 | $this->_info['sof']['ImageHeight'] = $this->_getShort($data, $pos + 1); |
||
| 1513 | $this->_info['sof']['ImageWidth'] = $this->_getShort($data, $pos + 3); |
||
| 1514 | $this->_info['sof']['ColorChannels'] = $this->_getByte($data, $pos + 5); |
||
| 1515 | |||
| 1516 | return true; |
||
| 1517 | } |
||
| 1518 | |||
| 1519 | /** |
||
| 1520 | * Parses the XMP data |
||
| 1521 | * |
||
| 1522 | * @author Hakan Sandell <[email protected]> |
||
| 1523 | */ |
||
| 1524 | function _parseMarkerXmp() { |
||
| 1525 | if (!isset($this->_markers)) { |
||
| 1526 | $this->_readJPEG(); |
||
| 1527 | } |
||
| 1528 | |||
| 1529 | if ($this->_markers == null) { |
||
| 1530 | return false; |
||
| 1531 | } |
||
| 1532 | |||
| 1533 | $data = null; |
||
| 1534 | $count = count($this->_markers); |
||
| 1535 | for ($i = 0; $i < $count; $i++) { |
||
| 1536 | if ($this->_markers[$i]['marker'] == 0xE1) { |
||
| 1537 | $signature = $this->_getFixedString($this->_markers[$i]['data'], 0, 29); |
||
| 1538 | if ($signature == "http://ns.adobe.com/xap/1.0/\0") { |
||
| 1539 | $data = substr($this->_markers[$i]['data'], 29); |
||
| 1540 | break; |
||
| 1541 | } |
||
| 1542 | } |
||
| 1543 | } |
||
| 1544 | |||
| 1545 | if ($data == null) { |
||
| 1546 | $this->_info['xmp'] = false; |
||
| 1547 | return false; |
||
| 1548 | } |
||
| 1549 | |||
| 1550 | $parser = xml_parser_create(); |
||
| 1551 | xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0); |
||
| 1552 | xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1); |
||
| 1553 | $result = xml_parse_into_struct($parser, $data, $values, $tags); |
||
| 1554 | xml_parser_free($parser); |
||
| 1555 | |||
| 1556 | if ($result == 0) { |
||
| 1557 | $this->_info['xmp'] = false; |
||
| 1558 | return false; |
||
| 1559 | } |
||
| 1560 | |||
| 1561 | $this->_info['xmp'] = array(); |
||
| 1562 | $count = count($values); |
||
| 1563 | for ($i = 0; $i < $count; $i++) { |
||
| 1564 | if ($values[$i]['tag'] == 'rdf:Description' && $values[$i]['type'] == 'open') { |
||
| 1565 | |||
| 1566 | while ((++$i < $count) && ($values[$i]['tag'] != 'rdf:Description')) { |
||
| 1567 | $this->_parseXmpNode($values, $i, $this->_info['xmp'][$values[$i]['tag']], $count); |
||
| 1568 | } |
||
| 1569 | } |
||
| 1570 | } |
||
| 1571 | return true; |
||
| 1572 | } |
||
| 1573 | |||
| 1574 | /** |
||
| 1575 | * Parses XMP nodes by recursion |
||
| 1576 | * |
||
| 1577 | * @author Hakan Sandell <[email protected]> |
||
| 1578 | * @param integer $count |
||
| 1579 | */ |
||
| 1580 | function _parseXmpNode($values, &$i, &$meta, $count) { |
||
| 1581 | if ($values[$i]['type'] == 'close') return; |
||
| 1582 | |||
| 1583 | if ($values[$i]['type'] == 'complete') { |
||
| 1584 | // Simple Type property |
||
| 1585 | $meta = $values[$i]['value']; |
||
| 1586 | return; |
||
| 1587 | } |
||
| 1588 | |||
| 1589 | $i++; |
||
| 1590 | if ($i >= $count) return; |
||
| 1591 | |||
| 1592 | if ($values[$i]['tag'] == 'rdf:Bag' || $values[$i]['tag'] == 'rdf:Seq') { |
||
| 1593 | // Array property |
||
| 1594 | $meta = array(); |
||
| 1595 | while ($values[++$i]['tag'] == 'rdf:li') { |
||
| 1596 | $this->_parseXmpNode($values, $i, $meta[], $count); |
||
| 1597 | } |
||
| 1598 | $i++; // skip closing Bag/Seq tag |
||
| 1599 | |||
| 1600 | } elseif ($values[$i]['tag'] == 'rdf:Alt') { |
||
| 1601 | // Language Alternative property, only the first (default) value is used |
||
| 1602 | if ($values[$i]['type'] == 'open') { |
||
| 1603 | $i++; |
||
| 1604 | $this->_parseXmpNode($values, $i, $meta, $count); |
||
| 1605 | while ((++$i < $count) && ($values[$i]['tag'] != 'rdf:Alt')); |
||
| 1606 | $i++; // skip closing Alt tag |
||
| 1607 | } |
||
| 1608 | |||
| 1609 | } else { |
||
| 1610 | // Structure property |
||
| 1611 | $meta = array(); |
||
| 1612 | $startTag = $values[$i-1]['tag']; |
||
| 1613 | do { |
||
| 1614 | $this->_parseXmpNode($values, $i, $meta[$values[$i]['tag']], $count); |
||
| 1615 | } while ((++$i < $count) && ($values[$i]['tag'] != $startTag)); |
||
| 1616 | } |
||
| 1617 | } |
||
| 1618 | |||
| 1619 | /*************************************************************/ |
||
| 1620 | function _parseMarkerExif() { |
||
| 1621 | if (!isset($this->_markers)) { |
||
| 1622 | $this->_readJPEG(); |
||
| 1623 | } |
||
| 1624 | |||
| 1625 | if ($this->_markers == null) { |
||
| 1626 | return false; |
||
| 1627 | } |
||
| 1628 | |||
| 1629 | $data = null; |
||
| 1630 | $count = count($this->_markers); |
||
| 1631 | for ($i = 0; $i < $count; $i++) { |
||
| 1632 | if ($this->_markers[$i]['marker'] == 0xE1) { |
||
| 1633 | $signature = $this->_getFixedString($this->_markers[$i]['data'], 0, 6); |
||
| 1634 | if ($signature == "Exif\0\0") { |
||
| 1635 | $data =& $this->_markers[$i]['data']; |
||
| 1636 | break; |
||
| 1637 | } |
||
| 1638 | } |
||
| 1639 | } |
||
| 1640 | |||
| 1641 | if ($data == null) { |
||
| 1642 | $this->_info['exif'] = false; |
||
| 1643 | return false; |
||
| 1644 | } |
||
| 1645 | $pos = 6; |
||
| 1646 | $this->_info['exif'] = array(); |
||
| 1647 | |||
| 1648 | // We don't increment $pos after this because Exif uses offsets relative to this point |
||
| 1649 | |||
| 1650 | $byteAlign = $this->_getShort($data, $pos + 0); |
||
| 1651 | |||
| 1652 | if ($byteAlign == 0x4949) { // "II" |
||
| 1653 | $isBigEndian = false; |
||
| 1654 | } elseif ($byteAlign == 0x4D4D) { // "MM" |
||
| 1655 | $isBigEndian = true; |
||
| 1656 | } else { |
||
| 1657 | return false; // Unexpected data |
||
| 1658 | } |
||
| 1659 | |||
| 1660 | $alignCheck = $this->_getShort($data, $pos + 2, $isBigEndian); |
||
| 1661 | if ($alignCheck != 0x002A) // That's the expected value |
||
| 1662 | return false; // Unexpected data |
||
| 1663 | |||
| 1664 | if ($isBigEndian) { |
||
| 1665 | $this->_info['exif']['ByteAlign'] = "Big Endian"; |
||
| 1666 | } else { |
||
| 1667 | $this->_info['exif']['ByteAlign'] = "Little Endian"; |
||
| 1668 | } |
||
| 1669 | |||
| 1670 | $offsetIFD0 = $this->_getLong($data, $pos + 4, $isBigEndian); |
||
| 1671 | if ($offsetIFD0 < 8) |
||
| 1672 | return false; // Unexpected data |
||
| 1673 | |||
| 1674 | $offsetIFD1 = $this->_readIFD($data, $pos, $offsetIFD0, $isBigEndian, 'ifd0'); |
||
| 1675 | if ($offsetIFD1 != 0) |
||
| 1676 | $this->_readIFD($data, $pos, $offsetIFD1, $isBigEndian, 'ifd1'); |
||
| 1677 | |||
| 1678 | return true; |
||
| 1679 | } |
||
| 1680 | |||
| 1681 | /*************************************************************/ |
||
| 1682 | |||
| 1683 | /** |
||
| 1684 | * @param integer $base |
||
| 1685 | * @param boolean $isBigEndian |
||
| 1686 | * @param string $mode |
||
| 1687 | */ |
||
| 1688 | function _readIFD($data, $base, $offset, $isBigEndian, $mode) { |
||
| 1898 | |||
| 1899 | /*************************************************************/ |
||
| 1900 | function & _createMarkerExif() { |
||
| 1901 | $data = null; |
||
| 1902 | $count = count($this->_markers); |
||
| 1903 | for ($i = 0; $i < $count; $i++) { |
||
| 1904 | if ($this->_markers[$i]['marker'] == 0xE1) { |
||
| 1905 | $signature = $this->_getFixedString($this->_markers[$i]['data'], 0, 6); |
||
| 1906 | if ($signature == "Exif\0\0") { |
||
| 1907 | $data =& $this->_markers[$i]['data']; |
||
| 1908 | break; |
||
| 1909 | } |
||
| 1910 | } |
||
| 1911 | } |
||
| 1912 | |||
| 1913 | if (!isset($this->_info['exif'])) { |
||
| 1914 | return false; |
||
| 1915 | } |
||
| 1916 | |||
| 1917 | $data = "Exif\0\0"; |
||
| 1918 | $pos = 6; |
||
| 1919 | $offsetBase = 6; |
||
| 1920 | |||
| 1921 | if (isset($this->_info['exif']['ByteAlign']) && ($this->_info['exif']['ByteAlign'] == "Big Endian")) { |
||
| 1922 | $isBigEndian = true; |
||
| 1923 | $aux = "MM"; |
||
| 1924 | $pos = $this->_putString($data, $pos, $aux); |
||
| 1925 | } else { |
||
| 1926 | $isBigEndian = false; |
||
| 1927 | $aux = "II"; |
||
| 1928 | $pos = $this->_putString($data, $pos, $aux); |
||
| 1929 | } |
||
| 1930 | $pos = $this->_putShort($data, $pos, 0x002A, $isBigEndian); |
||
| 1931 | $pos = $this->_putLong($data, $pos, 0x00000008, $isBigEndian); // IFD0 Offset is always 8 |
||
| 1932 | |||
| 1933 | $ifd0 =& $this->_getIFDEntries($isBigEndian, 'ifd0'); |
||
| 1934 | $ifd1 =& $this->_getIFDEntries($isBigEndian, 'ifd1'); |
||
| 1935 | |||
| 1936 | $pos = $this->_writeIFD($data, $pos, $offsetBase, $ifd0, $isBigEndian, true); |
||
| 1937 | $pos = $this->_writeIFD($data, $pos, $offsetBase, $ifd1, $isBigEndian, false); |
||
| 1938 | |||
| 1939 | return $data; |
||
| 1940 | } |
||
| 1941 | |||
| 1942 | /*************************************************************/ |
||
| 1943 | |||
| 1944 | /** |
||
| 1945 | * @param integer $offsetBase |
||
| 1946 | * @param boolean $isBigEndian |
||
| 1947 | * @param boolean $hasNext |
||
| 1948 | */ |
||
| 1949 | function _writeIFD(&$data, $pos, $offsetBase, &$entries, $isBigEndian, $hasNext) { |
||
| 1950 | $tiffData = null; |
||
| 1951 | $tiffDataOffsetPos = -1; |
||
| 1952 | |||
| 1953 | $entryCount = count($entries); |
||
| 1954 | |||
| 1955 | $dataPos = $pos + 2 + ($entryCount * 12) + 4; |
||
| 1956 | $pos = $this->_putShort($data, $pos, $entryCount, $isBigEndian); |
||
| 1957 | |||
| 1958 | for ($i = 0; $i < $entryCount; $i++) { |
||
| 1959 | $tag = $entries[$i]['tag']; |
||
| 1960 | $type = $entries[$i]['type']; |
||
| 1961 | |||
| 1962 | if ($type == -99) { // SubIFD |
||
| 1963 | $pos = $this->_putShort($data, $pos, $tag, $isBigEndian); |
||
| 1964 | $pos = $this->_putShort($data, $pos, 0x04, $isBigEndian); // LONG |
||
| 1965 | $pos = $this->_putLong($data, $pos, 0x01, $isBigEndian); // Count = 1 |
||
| 1966 | $pos = $this->_putLong($data, $pos, $dataPos - $offsetBase, $isBigEndian); |
||
| 1967 | |||
| 1968 | $dataPos = $this->_writeIFD($data, $dataPos, $offsetBase, $entries[$i]['value'], $isBigEndian, false); |
||
| 1969 | } elseif ($type == -98) { // TIFF Data |
||
| 1970 | $pos = $this->_putShort($data, $pos, $tag, $isBigEndian); |
||
| 1971 | $pos = $this->_putShort($data, $pos, 0x04, $isBigEndian); // LONG |
||
| 1972 | $pos = $this->_putLong($data, $pos, 0x01, $isBigEndian); // Count = 1 |
||
| 1973 | $tiffDataOffsetPos = $pos; |
||
| 1974 | $pos = $this->_putLong($data, $pos, 0x00, $isBigEndian); // For Now |
||
| 1975 | $tiffData =& $entries[$i]['value'] ; |
||
| 1976 | } else { // Regular Entry |
||
| 1977 | $pos = $this->_putShort($data, $pos, $tag, $isBigEndian); |
||
| 1978 | $pos = $this->_putShort($data, $pos, $type, $isBigEndian); |
||
| 1979 | $pos = $this->_putLong($data, $pos, $entries[$i]['count'], $isBigEndian); |
||
| 1980 | if (strlen($entries[$i]['value']) > 4) { |
||
| 1981 | $pos = $this->_putLong($data, $pos, $dataPos - $offsetBase, $isBigEndian); |
||
| 1982 | $dataPos = $this->_putString($data, $dataPos, $entries[$i]['value']); |
||
| 1983 | } else { |
||
| 1984 | $val = str_pad($entries[$i]['value'], 4, "\0"); |
||
| 1985 | $pos = $this->_putString($data, $pos, $val); |
||
| 1986 | } |
||
| 1987 | } |
||
| 1988 | } |
||
| 1989 | |||
| 1990 | if ($tiffData != null) { |
||
| 1991 | $this->_putLong($data, $tiffDataOffsetPos, $dataPos - $offsetBase, $isBigEndian); |
||
| 1992 | $dataPos = $this->_putString($data, $dataPos, $tiffData); |
||
| 1993 | } |
||
| 1994 | |||
| 1995 | if ($hasNext) { |
||
| 1996 | $pos = $this->_putLong($data, $pos, $dataPos - $offsetBase, $isBigEndian); |
||
| 1997 | } else { |
||
| 1998 | $pos = $this->_putLong($data, $pos, 0, $isBigEndian); |
||
| 1999 | } |
||
| 2000 | |||
| 2001 | return $dataPos; |
||
| 2002 | } |
||
| 2003 | |||
| 2004 | /*************************************************************/ |
||
| 2005 | |||
| 2006 | /** |
||
| 2007 | * @param boolean $isBigEndian |
||
| 2008 | * @param string $mode |
||
| 2009 | */ |
||
| 2010 | function & _getIFDEntries($isBigEndian, $mode) { |
||
| 2011 | $EXIFNames = $this->_exifTagNames($mode); |
||
| 2012 | $EXIFTags = $this->_exifNameTags($mode); |
||
| 2013 | $EXIFTypeInfo = $this->_exifTagTypes($mode); |
||
| 2014 | |||
| 2015 | $ifdEntries = array(); |
||
| 2016 | $entryCount = 0; |
||
| 2017 | |||
| 2018 | reset($EXIFNames); |
||
| 2019 | while (list($tag, $name) = each($EXIFNames)) { |
||
| 2020 | $type = $EXIFTypeInfo[$tag][0]; |
||
| 2021 | $count = $EXIFTypeInfo[$tag][1]; |
||
| 2022 | $value = null; |
||
| 2023 | |||
| 2024 | if (($mode == 'ifd0') && ($tag == 0x8769)) { // ExifIFDOffset |
||
| 2025 | if (isset($this->_info['exif']['EXIFVersion'])) { |
||
| 2026 | $value =& $this->_getIFDEntries($isBigEndian, "exif"); |
||
| 2027 | $type = -99; |
||
| 2028 | } |
||
| 2029 | else { |
||
| 2030 | $value = null; |
||
| 2031 | } |
||
| 2032 | } elseif (($mode == 'ifd0') && ($tag == 0x8825)) { // GPSIFDOffset |
||
| 2033 | if (isset($this->_info['exif']['GPSVersionID'])) { |
||
| 2034 | $value =& $this->_getIFDEntries($isBigEndian, "gps"); |
||
| 2035 | $type = -99; |
||
| 2036 | } else { |
||
| 2037 | $value = null; |
||
| 2038 | } |
||
| 2039 | } elseif (($mode == 'ifd1') && ($tag == 0x0111)) { // TIFFStripOffsets |
||
| 2040 | if (isset($this->_info['exif']['TIFFStrips'])) { |
||
| 2041 | $value =& $this->_info['exif']['TIFFStrips']; |
||
| 2042 | $type = -98; |
||
| 2043 | } else { |
||
| 2044 | $value = null; |
||
| 2045 | } |
||
| 2046 | } elseif (($mode == 'ifd1') && ($tag == 0x0117)) { // TIFFStripByteCounts |
||
| 2047 | if (isset($this->_info['exif']['TIFFStrips'])) { |
||
| 2048 | $value = strlen($this->_info['exif']['TIFFStrips']); |
||
| 2049 | } else { |
||
| 2050 | $value = null; |
||
| 2051 | } |
||
| 2052 | } elseif (($mode == 'ifd1') && ($tag == 0x0201)) { // TIFFJFIFOffset |
||
| 2053 | if (isset($this->_info['exif']['JFIFThumbnail'])) { |
||
| 2054 | $value =& $this->_info['exif']['JFIFThumbnail']; |
||
| 2055 | $type = -98; |
||
| 2056 | } else { |
||
| 2057 | $value = null; |
||
| 2058 | } |
||
| 2059 | } elseif (($mode == 'ifd1') && ($tag == 0x0202)) { // TIFFJFIFLength |
||
| 2060 | if (isset($this->_info['exif']['JFIFThumbnail'])) { |
||
| 2061 | $value = strlen($this->_info['exif']['JFIFThumbnail']); |
||
| 2062 | } else { |
||
| 2063 | $value = null; |
||
| 2064 | } |
||
| 2065 | } elseif (($mode == 'exif') && ($tag == 0xA005)) { // InteropIFDOffset |
||
| 2066 | if (isset($this->_info['exif']['InteroperabilityIndex'])) { |
||
| 2067 | $value =& $this->_getIFDEntries($isBigEndian, "interop"); |
||
| 2068 | $type = -99; |
||
| 2069 | } else { |
||
| 2070 | $value = null; |
||
| 2071 | } |
||
| 2072 | } elseif (isset($this->_info['exif'][$name])) { |
||
| 2073 | $origValue =& $this->_info['exif'][$name]; |
||
| 2074 | |||
| 2075 | // This makes it easier to process variable size elements |
||
| 2076 | if (!is_array($origValue) || isset($origValue['val'])) { |
||
| 2077 | unset($origValue); // Break the reference |
||
| 2078 | $origValue = array($this->_info['exif'][$name]); |
||
| 2079 | } |
||
| 2080 | $origCount = count($origValue); |
||
| 2081 | |||
| 2082 | if ($origCount == 0 ) { |
||
| 2083 | $type = -1; // To ignore this field |
||
| 2084 | } |
||
| 2085 | |||
| 2086 | $value = " "; |
||
| 2087 | |||
| 2088 | switch ($type) { |
||
| 2089 | case 1: // UBYTE |
||
| 2090 | if ($count == 0) { |
||
| 2091 | $count = $origCount; |
||
| 2092 | } |
||
| 2093 | |||
| 2094 | $j = 0; |
||
| 2095 | while (($j < $count) && ($j < $origCount)) { |
||
| 2096 | |||
| 2097 | $this->_putByte($value, $j, $origValue[$j]); |
||
| 2098 | $j++; |
||
| 2099 | } |
||
| 2100 | |||
| 2101 | while ($j < $count) { |
||
| 2102 | $this->_putByte($value, $j, 0); |
||
| 2103 | $j++; |
||
| 2104 | } |
||
| 2105 | break; |
||
| 2106 | case 2: // ASCII |
||
| 2107 | $v = strval($origValue[0]); |
||
| 2108 | if (($count != 0) && (strlen($v) > $count)) { |
||
| 2109 | $v = substr($v, 0, $count); |
||
| 2110 | } |
||
| 2111 | elseif (($count > 0) && (strlen($v) < $count)) { |
||
| 2112 | $v = str_pad($v, $count, "\0"); |
||
| 2113 | } |
||
| 2114 | |||
| 2115 | $count = strlen($v); |
||
| 2116 | |||
| 2117 | $this->_putString($value, 0, $v); |
||
| 2118 | break; |
||
| 2119 | case 3: // USHORT |
||
| 2120 | if ($count == 0) { |
||
| 2121 | $count = $origCount; |
||
| 2122 | } |
||
| 2123 | |||
| 2124 | $j = 0; |
||
| 2125 | while (($j < $count) && ($j < $origCount)) { |
||
| 2126 | $this->_putShort($value, $j * 2, $origValue[$j], $isBigEndian); |
||
| 2127 | $j++; |
||
| 2128 | } |
||
| 2129 | |||
| 2130 | while ($j < $count) { |
||
| 2131 | $this->_putShort($value, $j * 2, 0, $isBigEndian); |
||
| 2132 | $j++; |
||
| 2133 | } |
||
| 2134 | break; |
||
| 2135 | case 4: // ULONG |
||
| 2136 | if ($count == 0) { |
||
| 2137 | $count = $origCount; |
||
| 2138 | } |
||
| 2139 | |||
| 2140 | $j = 0; |
||
| 2141 | while (($j < $count) && ($j < $origCount)) { |
||
| 2142 | $this->_putLong($value, $j * 4, $origValue[$j], $isBigEndian); |
||
| 2143 | $j++; |
||
| 2144 | } |
||
| 2145 | |||
| 2146 | while ($j < $count) { |
||
| 2147 | $this->_putLong($value, $j * 4, 0, $isBigEndian); |
||
| 2148 | $j++; |
||
| 2149 | } |
||
| 2150 | break; |
||
| 2151 | case 5: // URATIONAL |
||
| 2152 | if ($count == 0) { |
||
| 2153 | $count = $origCount; |
||
| 2154 | } |
||
| 2155 | |||
| 2156 | $j = 0; |
||
| 2157 | while (($j < $count) && ($j < $origCount)) { |
||
| 2158 | $v = $origValue[$j]; |
||
| 2159 | if (is_array($v)) { |
||
| 2160 | $a = $v['num']; |
||
| 2161 | $b = $v['den']; |
||
| 2162 | } |
||
| 2163 | else { |
||
| 2164 | $a = 0; |
||
| 2165 | $b = 0; |
||
| 2166 | // TODO: Allow other types and convert them |
||
| 2167 | } |
||
| 2168 | $this->_putLong($value, $j * 8, $a, $isBigEndian); |
||
| 2169 | $this->_putLong($value, ($j * 8) + 4, $b, $isBigEndian); |
||
| 2170 | $j++; |
||
| 2171 | } |
||
| 2172 | |||
| 2173 | while ($j < $count) { |
||
| 2174 | $this->_putLong($value, $j * 8, 0, $isBigEndian); |
||
| 2175 | $this->_putLong($value, ($j * 8) + 4, 0, $isBigEndian); |
||
| 2176 | $j++; |
||
| 2177 | } |
||
| 2178 | break; |
||
| 2179 | case 6: // SBYTE |
||
| 2180 | if ($count == 0) { |
||
| 2181 | $count = $origCount; |
||
| 2182 | } |
||
| 2183 | |||
| 2184 | $j = 0; |
||
| 2185 | while (($j < $count) && ($j < $origCount)) { |
||
| 2186 | $this->_putByte($value, $j, $origValue[$j]); |
||
| 2187 | $j++; |
||
| 2188 | } |
||
| 2189 | |||
| 2190 | while ($j < $count) { |
||
| 2191 | $this->_putByte($value, $j, 0); |
||
| 2192 | $j++; |
||
| 2193 | } |
||
| 2194 | break; |
||
| 2195 | case 7: // UNDEFINED |
||
| 2196 | $v = strval($origValue[0]); |
||
| 2197 | if (($count != 0) && (strlen($v) > $count)) { |
||
| 2198 | $v = substr($v, 0, $count); |
||
| 2199 | } |
||
| 2200 | elseif (($count > 0) && (strlen($v) < $count)) { |
||
| 2201 | $v = str_pad($v, $count, "\0"); |
||
| 2202 | } |
||
| 2203 | |||
| 2204 | $count = strlen($v); |
||
| 2205 | |||
| 2206 | $this->_putString($value, 0, $v); |
||
| 2207 | break; |
||
| 2208 | case 8: // SSHORT |
||
| 2209 | if ($count == 0) { |
||
| 2210 | $count = $origCount; |
||
| 2211 | } |
||
| 2212 | |||
| 2213 | $j = 0; |
||
| 2214 | while (($j < $count) && ($j < $origCount)) { |
||
| 2215 | $this->_putShort($value, $j * 2, $origValue[$j], $isBigEndian); |
||
| 2216 | $j++; |
||
| 2217 | } |
||
| 2218 | |||
| 2219 | while ($j < $count) { |
||
| 2220 | $this->_putShort($value, $j * 2, 0, $isBigEndian); |
||
| 2221 | $j++; |
||
| 2222 | } |
||
| 2223 | break; |
||
| 2224 | case 9: // SLONG |
||
| 2225 | if ($count == 0) { |
||
| 2226 | $count = $origCount; |
||
| 2227 | } |
||
| 2228 | |||
| 2229 | $j = 0; |
||
| 2230 | while (($j < $count) && ($j < $origCount)) { |
||
| 2231 | $this->_putLong($value, $j * 4, $origValue[$j], $isBigEndian); |
||
| 2232 | $j++; |
||
| 2233 | } |
||
| 2234 | |||
| 2235 | while ($j < $count) { |
||
| 2236 | $this->_putLong($value, $j * 4, 0, $isBigEndian); |
||
| 2237 | $j++; |
||
| 2238 | } |
||
| 2239 | break; |
||
| 2240 | case 10: // SRATIONAL |
||
| 2241 | if ($count == 0) { |
||
| 2242 | $count = $origCount; |
||
| 2243 | } |
||
| 2244 | |||
| 2245 | $j = 0; |
||
| 2246 | while (($j < $count) && ($j < $origCount)) { |
||
| 2247 | $v = $origValue[$j]; |
||
| 2248 | if (is_array($v)) { |
||
| 2249 | $a = $v['num']; |
||
| 2250 | $b = $v['den']; |
||
| 2251 | } |
||
| 2252 | else { |
||
| 2253 | $a = 0; |
||
| 2254 | $b = 0; |
||
| 2255 | // TODO: Allow other types and convert them |
||
| 2256 | } |
||
| 2257 | |||
| 2258 | $this->_putLong($value, $j * 8, $a, $isBigEndian); |
||
| 2259 | $this->_putLong($value, ($j * 8) + 4, $b, $isBigEndian); |
||
| 2260 | $j++; |
||
| 2261 | } |
||
| 2262 | |||
| 2263 | while ($j < $count) { |
||
| 2264 | $this->_putLong($value, $j * 8, 0, $isBigEndian); |
||
| 2265 | $this->_putLong($value, ($j * 8) + 4, 0, $isBigEndian); |
||
| 2266 | $j++; |
||
| 2267 | } |
||
| 2268 | break; |
||
| 2269 | case 11: // FLOAT |
||
| 2270 | if ($count == 0) { |
||
| 2271 | $count = $origCount; |
||
| 2272 | } |
||
| 2273 | |||
| 2274 | $j = 0; |
||
| 2275 | while (($j < $count) && ($j < $origCount)) { |
||
| 2276 | $v = strval($origValue[$j]); |
||
| 2277 | if (strlen($v) > 4) { |
||
| 2278 | $v = substr($v, 0, 4); |
||
| 2279 | } |
||
| 2280 | elseif (strlen($v) < 4) { |
||
| 2281 | $v = str_pad($v, 4, "\0"); |
||
| 2282 | } |
||
| 2283 | $this->_putString($value, $j * 4, $v); |
||
| 2284 | $j++; |
||
| 2285 | } |
||
| 2286 | |||
| 2287 | while ($j < $count) { |
||
| 2288 | $v = "\0\0\0\0"; |
||
| 2289 | $this->_putString($value, $j * 4, $v); |
||
| 2290 | $j++; |
||
| 2291 | } |
||
| 2292 | break; |
||
| 2293 | case 12: // DFLOAT |
||
| 2294 | if ($count == 0) { |
||
| 2295 | $count = $origCount; |
||
| 2296 | } |
||
| 2297 | |||
| 2298 | $j = 0; |
||
| 2299 | while (($j < $count) && ($j < $origCount)) { |
||
| 2300 | $v = strval($origValue[$j]); |
||
| 2301 | if (strlen($v) > 8) { |
||
| 2302 | $v = substr($v, 0, 8); |
||
| 2303 | } |
||
| 2304 | elseif (strlen($v) < 8) { |
||
| 2305 | $v = str_pad($v, 8, "\0"); |
||
| 2306 | } |
||
| 2307 | $this->_putString($value, $j * 8, $v); |
||
| 2308 | $j++; |
||
| 2309 | } |
||
| 2310 | |||
| 2311 | while ($j < $count) { |
||
| 2312 | $v = "\0\0\0\0\0\0\0\0"; |
||
| 2313 | $this->_putString($value, $j * 8, $v); |
||
| 2314 | $j++; |
||
| 2315 | } |
||
| 2316 | break; |
||
| 2317 | default: |
||
| 2318 | $value = null; |
||
| 2319 | break; |
||
| 2320 | } |
||
| 2321 | } |
||
| 2322 | |||
| 2323 | if ($value != null) { |
||
| 2324 | $ifdEntries[$entryCount] = array(); |
||
| 2325 | $ifdEntries[$entryCount]['tag'] = $tag; |
||
| 2326 | $ifdEntries[$entryCount]['type'] = $type; |
||
| 2327 | $ifdEntries[$entryCount]['count'] = $count; |
||
| 2328 | $ifdEntries[$entryCount]['value'] = $value; |
||
| 2329 | |||
| 2330 | $entryCount++; |
||
| 2331 | } |
||
| 2332 | } |
||
| 2333 | |||
| 2334 | return $ifdEntries; |
||
| 2335 | } |
||
| 2336 | |||
| 2337 | /*************************************************************/ |
||
| 2338 | function _parseMarkerAdobe() { |
||
| 2339 | if (!isset($this->_markers)) { |
||
| 2340 | $this->_readJPEG(); |
||
| 2341 | } |
||
| 2342 | |||
| 2343 | if ($this->_markers == null) { |
||
| 2344 | return false; |
||
| 2345 | } |
||
| 2346 | |||
| 2347 | $data = null; |
||
| 2348 | $count = count($this->_markers); |
||
| 2349 | for ($i = 0; $i < $count; $i++) { |
||
| 2350 | if ($this->_markers[$i]['marker'] == 0xED) { |
||
| 2351 | $signature = $this->_getFixedString($this->_markers[$i]['data'], 0, 14); |
||
| 2352 | if ($signature == "Photoshop 3.0\0") { |
||
| 2353 | $data =& $this->_markers[$i]['data']; |
||
| 2354 | break; |
||
| 2355 | } |
||
| 2356 | } |
||
| 2357 | } |
||
| 2358 | |||
| 2359 | if ($data == null) { |
||
| 2360 | $this->_info['adobe'] = false; |
||
| 2361 | $this->_info['iptc'] = false; |
||
| 2362 | return false; |
||
| 2363 | } |
||
| 2364 | $pos = 14; |
||
| 2365 | $this->_info['adobe'] = array(); |
||
| 2366 | $this->_info['adobe']['raw'] = array(); |
||
| 2367 | $this->_info['iptc'] = array(); |
||
| 2368 | |||
| 2369 | $datasize = strlen($data); |
||
| 2370 | |||
| 2371 | while ($pos < $datasize) { |
||
| 2372 | $signature = $this->_getFixedString($data, $pos, 4); |
||
| 2373 | if ($signature != '8BIM') |
||
| 2374 | return false; |
||
| 2375 | $pos += 4; |
||
| 2376 | |||
| 2377 | $type = $this->_getShort($data, $pos); |
||
| 2378 | $pos += 2; |
||
| 2379 | |||
| 2380 | $strlen = $this->_getByte($data, $pos); |
||
| 2381 | $pos += 1; |
||
| 2382 | $header = ''; |
||
| 2383 | for ($i = 0; $i < $strlen; $i++) { |
||
| 2384 | $header .= $data{$pos + $i}; |
||
| 2385 | } |
||
| 2386 | $pos += $strlen + 1 - ($strlen % 2); // The string is padded to even length, counting the length byte itself |
||
| 2387 | |||
| 2388 | $length = $this->_getLong($data, $pos); |
||
| 2389 | $pos += 4; |
||
| 2390 | |||
| 2391 | $basePos = $pos; |
||
| 2392 | |||
| 2393 | switch ($type) { |
||
| 2394 | case 0x0404: // Caption (IPTC Data) |
||
| 2395 | $pos = $this->_readIPTC($data, $pos); |
||
| 2396 | if ($pos == false) |
||
| 2397 | return false; |
||
| 2398 | break; |
||
| 2399 | case 0x040A: // CopyrightFlag |
||
| 2400 | $this->_info['adobe']['CopyrightFlag'] = $this->_getByte($data, $pos); |
||
| 2401 | $pos += $length; |
||
| 2402 | break; |
||
| 2403 | case 0x040B: // ImageURL |
||
| 2404 | $this->_info['adobe']['ImageURL'] = $this->_getFixedString($data, $pos, $length); |
||
| 2405 | $pos += $length; |
||
| 2406 | break; |
||
| 2407 | case 0x040C: // Thumbnail |
||
| 2408 | $aux = $this->_getLong($data, $pos); |
||
| 2409 | $pos += 4; |
||
| 2410 | if ($aux == 1) { |
||
| 2411 | $this->_info['adobe']['ThumbnailWidth'] = $this->_getLong($data, $pos); |
||
| 2412 | $pos += 4; |
||
| 2413 | $this->_info['adobe']['ThumbnailHeight'] = $this->_getLong($data, $pos); |
||
| 2414 | $pos += 4; |
||
| 2415 | |||
| 2416 | $pos += 16; // Skip some data |
||
| 2417 | |||
| 2418 | $this->_info['adobe']['ThumbnailData'] = $this->_getFixedString($data, $pos, $length - 28); |
||
| 2419 | $pos += $length - 28; |
||
| 2420 | } |
||
| 2421 | break; |
||
| 2422 | default: |
||
| 2423 | break; |
||
| 2424 | } |
||
| 2425 | |||
| 2426 | // We save all blocks, even those we recognized |
||
| 2427 | $label = sprintf('8BIM_0x%04x', $type); |
||
| 2428 | $this->_info['adobe']['raw'][$label] = array(); |
||
| 2429 | $this->_info['adobe']['raw'][$label]['type'] = $type; |
||
| 2430 | $this->_info['adobe']['raw'][$label]['header'] = $header; |
||
| 2431 | $this->_info['adobe']['raw'][$label]['data'] =& $this->_getFixedString($data, $basePos, $length); |
||
| 2432 | |||
| 2433 | $pos = $basePos + $length + ($length % 2); // Even padding |
||
| 2434 | } |
||
| 2435 | |||
| 2436 | } |
||
| 2437 | |||
| 2438 | /*************************************************************/ |
||
| 2439 | function _readIPTC(&$data, $pos = 0) { |
||
| 2440 | $totalLength = strlen($data); |
||
| 2441 | |||
| 2442 | $IPTCTags = $this->_iptcTagNames(); |
||
| 2443 | |||
| 2444 | while ($pos < ($totalLength - 5)) { |
||
| 2445 | $signature = $this->_getShort($data, $pos); |
||
| 2446 | if ($signature != 0x1C02) |
||
| 2447 | return $pos; |
||
| 2448 | $pos += 2; |
||
| 2449 | |||
| 2450 | $type = $this->_getByte($data, $pos); |
||
| 2451 | $pos += 1; |
||
| 2452 | $length = $this->_getShort($data, $pos); |
||
| 2453 | $pos += 2; |
||
| 2454 | |||
| 2455 | $basePos = $pos; |
||
| 2456 | $label = ''; |
||
| 2457 | |||
| 2458 | if (isset($IPTCTags[$type])) { |
||
| 2459 | $label = $IPTCTags[$type]; |
||
| 2460 | } else { |
||
| 2461 | $label = sprintf('IPTC_0x%02x', $type); |
||
| 2462 | } |
||
| 2463 | |||
| 2464 | if ($label != '') { |
||
| 2465 | if (isset($this->_info['iptc'][$label])) { |
||
| 2466 | if (!is_array($this->_info['iptc'][$label])) { |
||
| 2467 | $aux = array(); |
||
| 2468 | $aux[0] = $this->_info['iptc'][$label]; |
||
| 2469 | $this->_info['iptc'][$label] = $aux; |
||
| 2470 | } |
||
| 2471 | $this->_info['iptc'][$label][ count($this->_info['iptc'][$label]) ] = $this->_getFixedString($data, $pos, $length); |
||
| 2472 | } else { |
||
| 2473 | $this->_info['iptc'][$label] = $this->_getFixedString($data, $pos, $length); |
||
| 2474 | } |
||
| 2475 | } |
||
| 2476 | |||
| 2477 | $pos = $basePos + $length; // No padding |
||
| 2478 | } |
||
| 2479 | return $pos; |
||
| 2480 | } |
||
| 2481 | |||
| 2482 | /*************************************************************/ |
||
| 2483 | function & _createMarkerAdobe() { |
||
| 2484 | if (isset($this->_info['iptc'])) { |
||
| 2485 | if (!isset($this->_info['adobe'])) { |
||
| 2486 | $this->_info['adobe'] = array(); |
||
| 2487 | } |
||
| 2488 | if (!isset($this->_info['adobe']['raw'])) { |
||
| 2489 | $this->_info['adobe']['raw'] = array(); |
||
| 2490 | } |
||
| 2491 | if (!isset($this->_info['adobe']['raw']['8BIM_0x0404'])) { |
||
| 2492 | $this->_info['adobe']['raw']['8BIM_0x0404'] = array(); |
||
| 2493 | } |
||
| 2494 | $this->_info['adobe']['raw']['8BIM_0x0404']['type'] = 0x0404; |
||
| 2495 | $this->_info['adobe']['raw']['8BIM_0x0404']['header'] = "Caption"; |
||
| 2496 | $this->_info['adobe']['raw']['8BIM_0x0404']['data'] =& $this->_writeIPTC(); |
||
| 2497 | } |
||
| 2498 | |||
| 2499 | if (isset($this->_info['adobe']['raw']) && (count($this->_info['adobe']['raw']) > 0)) { |
||
| 2500 | $data = "Photoshop 3.0\0"; |
||
| 2501 | $pos = 14; |
||
| 2502 | |||
| 2503 | reset($this->_info['adobe']['raw']); |
||
| 2504 | while (list($key) = each($this->_info['adobe']['raw'])) { |
||
| 2505 | $pos = $this->_write8BIM( |
||
| 2506 | $data, |
||
| 2507 | $pos, |
||
| 2508 | $this->_info['adobe']['raw'][$key]['type'], |
||
| 2509 | $this->_info['adobe']['raw'][$key]['header'], |
||
| 2510 | $this->_info['adobe']['raw'][$key]['data'] ); |
||
| 2511 | } |
||
| 2512 | } |
||
| 2513 | |||
| 2514 | return $data; |
||
| 2515 | } |
||
| 2516 | |||
| 2517 | /*************************************************************/ |
||
| 2518 | |||
| 2519 | /** |
||
| 2520 | * @param integer $pos |
||
| 2521 | */ |
||
| 2522 | function _write8BIM(&$data, $pos, $type, $header, &$value) { |
||
| 2544 | |||
| 2545 | /*************************************************************/ |
||
| 2546 | function & _writeIPTC() { |
||
| 2547 | $data = " "; |
||
| 2548 | $pos = 0; |
||
| 2549 | |||
| 2550 | $IPTCNames =& $this->_iptcNameTags(); |
||
| 2551 | |||
| 2552 | reset($this->_info['iptc']); |
||
| 2553 | |||
| 2554 | while (list($label) = each($this->_info['iptc'])) { |
||
| 2555 | $value =& $this->_info['iptc'][$label]; |
||
| 2556 | $type = -1; |
||
| 2557 | |||
| 2558 | if (isset($IPTCNames[$label])) { |
||
| 2559 | $type = $IPTCNames[$label]; |
||
| 2560 | } |
||
| 2561 | elseif (substr($label, 0, 7) == "IPTC_0x") { |
||
| 2562 | $type = hexdec(substr($label, 7, 2)); |
||
| 2563 | } |
||
| 2564 | |||
| 2565 | if ($type != -1) { |
||
| 2566 | if (is_array($value)) { |
||
| 2567 | $vcnt = count($value); |
||
| 2568 | for ($i = 0; $i < $vcnt; $i++) { |
||
| 2569 | $pos = $this->_writeIPTCEntry($data, $pos, $type, $value[$i]); |
||
| 2570 | } |
||
| 2571 | } |
||
| 2572 | else { |
||
| 2573 | $pos = $this->_writeIPTCEntry($data, $pos, $type, $value); |
||
| 2574 | } |
||
| 2575 | } |
||
| 2576 | } |
||
| 2577 | |||
| 2578 | return $data; |
||
| 2579 | } |
||
| 2580 | |||
| 2581 | /*************************************************************/ |
||
| 2582 | |||
| 2583 | /** |
||
| 2584 | * @param integer $pos |
||
| 2585 | */ |
||
| 2586 | function _writeIPTCEntry(&$data, $pos, $type, &$value) { |
||
| 2587 | $pos = $this->_putShort($data, $pos, 0x1C02); |
||
| 2588 | $pos = $this->_putByte($data, $pos, $type); |
||
| 2589 | $pos = $this->_putShort($data, $pos, strlen($value)); |
||
| 2590 | $pos = $this->_putString($data, $pos, $value); |
||
| 2591 | |||
| 2592 | return $pos; |
||
| 2593 | } |
||
| 2594 | |||
| 2595 | /*************************************************************/ |
||
| 2596 | function _exifTagNames($mode) { |
||
| 2597 | $tags = array(); |
||
| 2598 | |||
| 2599 | if ($mode == 'ifd0') { |
||
| 2600 | $tags[0x010E] = 'ImageDescription'; |
||
| 2601 | $tags[0x010F] = 'Make'; |
||
| 2602 | $tags[0x0110] = 'Model'; |
||
| 2603 | $tags[0x0112] = 'Orientation'; |
||
| 2604 | $tags[0x011A] = 'XResolution'; |
||
| 2605 | $tags[0x011B] = 'YResolution'; |
||
| 2606 | $tags[0x0128] = 'ResolutionUnit'; |
||
| 2607 | $tags[0x0131] = 'Software'; |
||
| 2608 | $tags[0x0132] = 'DateTime'; |
||
| 2609 | $tags[0x013B] = 'Artist'; |
||
| 2610 | $tags[0x013E] = 'WhitePoint'; |
||
| 2611 | $tags[0x013F] = 'PrimaryChromaticities'; |
||
| 2612 | $tags[0x0211] = 'YCbCrCoefficients'; |
||
| 2613 | $tags[0x0212] = 'YCbCrSubSampling'; |
||
| 2614 | $tags[0x0213] = 'YCbCrPositioning'; |
||
| 2615 | $tags[0x0214] = 'ReferenceBlackWhite'; |
||
| 2616 | $tags[0x8298] = 'Copyright'; |
||
| 2617 | $tags[0x8769] = 'ExifIFDOffset'; |
||
| 2618 | $tags[0x8825] = 'GPSIFDOffset'; |
||
| 2619 | } |
||
| 2620 | if ($mode == 'ifd1') { |
||
| 2621 | $tags[0x00FE] = 'TIFFNewSubfileType'; |
||
| 2622 | $tags[0x00FF] = 'TIFFSubfileType'; |
||
| 2623 | $tags[0x0100] = 'TIFFImageWidth'; |
||
| 2624 | $tags[0x0101] = 'TIFFImageHeight'; |
||
| 2625 | $tags[0x0102] = 'TIFFBitsPerSample'; |
||
| 2626 | $tags[0x0103] = 'TIFFCompression'; |
||
| 2627 | $tags[0x0106] = 'TIFFPhotometricInterpretation'; |
||
| 2628 | $tags[0x0107] = 'TIFFThreshholding'; |
||
| 2629 | $tags[0x0108] = 'TIFFCellWidth'; |
||
| 2630 | $tags[0x0109] = 'TIFFCellLength'; |
||
| 2631 | $tags[0x010A] = 'TIFFFillOrder'; |
||
| 2632 | $tags[0x010E] = 'TIFFImageDescription'; |
||
| 2633 | $tags[0x010F] = 'TIFFMake'; |
||
| 2634 | $tags[0x0110] = 'TIFFModel'; |
||
| 2635 | $tags[0x0111] = 'TIFFStripOffsets'; |
||
| 2636 | $tags[0x0112] = 'TIFFOrientation'; |
||
| 2637 | $tags[0x0115] = 'TIFFSamplesPerPixel'; |
||
| 2638 | $tags[0x0116] = 'TIFFRowsPerStrip'; |
||
| 2639 | $tags[0x0117] = 'TIFFStripByteCounts'; |
||
| 2640 | $tags[0x0118] = 'TIFFMinSampleValue'; |
||
| 2641 | $tags[0x0119] = 'TIFFMaxSampleValue'; |
||
| 2642 | $tags[0x011A] = 'TIFFXResolution'; |
||
| 2643 | $tags[0x011B] = 'TIFFYResolution'; |
||
| 2644 | $tags[0x011C] = 'TIFFPlanarConfiguration'; |
||
| 2645 | $tags[0x0122] = 'TIFFGrayResponseUnit'; |
||
| 2646 | $tags[0x0123] = 'TIFFGrayResponseCurve'; |
||
| 2647 | $tags[0x0128] = 'TIFFResolutionUnit'; |
||
| 2648 | $tags[0x0131] = 'TIFFSoftware'; |
||
| 2649 | $tags[0x0132] = 'TIFFDateTime'; |
||
| 2650 | $tags[0x013B] = 'TIFFArtist'; |
||
| 2651 | $tags[0x013C] = 'TIFFHostComputer'; |
||
| 2652 | $tags[0x0140] = 'TIFFColorMap'; |
||
| 2653 | $tags[0x0152] = 'TIFFExtraSamples'; |
||
| 2654 | $tags[0x0201] = 'TIFFJFIFOffset'; |
||
| 2655 | $tags[0x0202] = 'TIFFJFIFLength'; |
||
| 2656 | $tags[0x0211] = 'TIFFYCbCrCoefficients'; |
||
| 2657 | $tags[0x0212] = 'TIFFYCbCrSubSampling'; |
||
| 2658 | $tags[0x0213] = 'TIFFYCbCrPositioning'; |
||
| 2659 | $tags[0x0214] = 'TIFFReferenceBlackWhite'; |
||
| 2660 | $tags[0x8298] = 'TIFFCopyright'; |
||
| 2661 | $tags[0x9286] = 'TIFFUserComment'; |
||
| 2662 | } elseif ($mode == 'exif') { |
||
| 2663 | $tags[0x829A] = 'ExposureTime'; |
||
| 2664 | $tags[0x829D] = 'FNumber'; |
||
| 2665 | $tags[0x8822] = 'ExposureProgram'; |
||
| 2666 | $tags[0x8824] = 'SpectralSensitivity'; |
||
| 2667 | $tags[0x8827] = 'ISOSpeedRatings'; |
||
| 2668 | $tags[0x8828] = 'OECF'; |
||
| 2669 | $tags[0x9000] = 'EXIFVersion'; |
||
| 2670 | $tags[0x9003] = 'DatetimeOriginal'; |
||
| 2671 | $tags[0x9004] = 'DatetimeDigitized'; |
||
| 2672 | $tags[0x9101] = 'ComponentsConfiguration'; |
||
| 2673 | $tags[0x9102] = 'CompressedBitsPerPixel'; |
||
| 2674 | $tags[0x9201] = 'ShutterSpeedValue'; |
||
| 2675 | $tags[0x9202] = 'ApertureValue'; |
||
| 2676 | $tags[0x9203] = 'BrightnessValue'; |
||
| 2677 | $tags[0x9204] = 'ExposureBiasValue'; |
||
| 2678 | $tags[0x9205] = 'MaxApertureValue'; |
||
| 2679 | $tags[0x9206] = 'SubjectDistance'; |
||
| 2680 | $tags[0x9207] = 'MeteringMode'; |
||
| 2681 | $tags[0x9208] = 'LightSource'; |
||
| 2682 | $tags[0x9209] = 'Flash'; |
||
| 2683 | $tags[0x920A] = 'FocalLength'; |
||
| 2684 | $tags[0x927C] = 'MakerNote'; |
||
| 2685 | $tags[0x9286] = 'UserComment'; |
||
| 2686 | $tags[0x9290] = 'SubSecTime'; |
||
| 2687 | $tags[0x9291] = 'SubSecTimeOriginal'; |
||
| 2688 | $tags[0x9292] = 'SubSecTimeDigitized'; |
||
| 2689 | $tags[0xA000] = 'FlashPixVersion'; |
||
| 2690 | $tags[0xA001] = 'ColorSpace'; |
||
| 2691 | $tags[0xA002] = 'PixelXDimension'; |
||
| 2692 | $tags[0xA003] = 'PixelYDimension'; |
||
| 2693 | $tags[0xA004] = 'RelatedSoundFile'; |
||
| 2694 | $tags[0xA005] = 'InteropIFDOffset'; |
||
| 2695 | $tags[0xA20B] = 'FlashEnergy'; |
||
| 2696 | $tags[0xA20C] = 'SpatialFrequencyResponse'; |
||
| 2697 | $tags[0xA20E] = 'FocalPlaneXResolution'; |
||
| 2698 | $tags[0xA20F] = 'FocalPlaneYResolution'; |
||
| 2699 | $tags[0xA210] = 'FocalPlaneResolutionUnit'; |
||
| 2700 | $tags[0xA214] = 'SubjectLocation'; |
||
| 2701 | $tags[0xA215] = 'ExposureIndex'; |
||
| 2702 | $tags[0xA217] = 'SensingMethod'; |
||
| 2703 | $tags[0xA300] = 'FileSource'; |
||
| 2704 | $tags[0xA301] = 'SceneType'; |
||
| 2705 | $tags[0xA302] = 'CFAPattern'; |
||
| 2706 | } elseif ($mode == 'interop') { |
||
| 2707 | $tags[0x0001] = 'InteroperabilityIndex'; |
||
| 2708 | $tags[0x0002] = 'InteroperabilityVersion'; |
||
| 2709 | $tags[0x1000] = 'RelatedImageFileFormat'; |
||
| 2710 | $tags[0x1001] = 'RelatedImageWidth'; |
||
| 2711 | $tags[0x1002] = 'RelatedImageLength'; |
||
| 2712 | } elseif ($mode == 'gps') { |
||
| 2713 | $tags[0x0000] = 'GPSVersionID'; |
||
| 2714 | $tags[0x0001] = 'GPSLatitudeRef'; |
||
| 2715 | $tags[0x0002] = 'GPSLatitude'; |
||
| 2716 | $tags[0x0003] = 'GPSLongitudeRef'; |
||
| 2717 | $tags[0x0004] = 'GPSLongitude'; |
||
| 2718 | $tags[0x0005] = 'GPSAltitudeRef'; |
||
| 2719 | $tags[0x0006] = 'GPSAltitude'; |
||
| 2720 | $tags[0x0007] = 'GPSTimeStamp'; |
||
| 2721 | $tags[0x0008] = 'GPSSatellites'; |
||
| 2722 | $tags[0x0009] = 'GPSStatus'; |
||
| 2723 | $tags[0x000A] = 'GPSMeasureMode'; |
||
| 2724 | $tags[0x000B] = 'GPSDOP'; |
||
| 2725 | $tags[0x000C] = 'GPSSpeedRef'; |
||
| 2726 | $tags[0x000D] = 'GPSSpeed'; |
||
| 2727 | $tags[0x000E] = 'GPSTrackRef'; |
||
| 2728 | $tags[0x000F] = 'GPSTrack'; |
||
| 2729 | $tags[0x0010] = 'GPSImgDirectionRef'; |
||
| 2730 | $tags[0x0011] = 'GPSImgDirection'; |
||
| 2731 | $tags[0x0012] = 'GPSMapDatum'; |
||
| 2732 | $tags[0x0013] = 'GPSDestLatitudeRef'; |
||
| 2733 | $tags[0x0014] = 'GPSDestLatitude'; |
||
| 2734 | $tags[0x0015] = 'GPSDestLongitudeRef'; |
||
| 2735 | $tags[0x0016] = 'GPSDestLongitude'; |
||
| 2736 | $tags[0x0017] = 'GPSDestBearingRef'; |
||
| 2737 | $tags[0x0018] = 'GPSDestBearing'; |
||
| 2738 | $tags[0x0019] = 'GPSDestDistanceRef'; |
||
| 2739 | $tags[0x001A] = 'GPSDestDistance'; |
||
| 2740 | } |
||
| 2741 | |||
| 2742 | return $tags; |
||
| 2743 | } |
||
| 2744 | |||
| 2745 | /*************************************************************/ |
||
| 2746 | function _exifTagTypes($mode) { |
||
| 2747 | $tags = array(); |
||
| 2748 | |||
| 2749 | if ($mode == 'ifd0') { |
||
| 2750 | $tags[0x010E] = array(2, 0); // ImageDescription -> ASCII, Any |
||
| 2751 | $tags[0x010F] = array(2, 0); // Make -> ASCII, Any |
||
| 2752 | $tags[0x0110] = array(2, 0); // Model -> ASCII, Any |
||
| 2753 | $tags[0x0112] = array(3, 1); // Orientation -> SHORT, 1 |
||
| 2754 | $tags[0x011A] = array(5, 1); // XResolution -> RATIONAL, 1 |
||
| 2755 | $tags[0x011B] = array(5, 1); // YResolution -> RATIONAL, 1 |
||
| 2756 | $tags[0x0128] = array(3, 1); // ResolutionUnit -> SHORT |
||
| 2757 | $tags[0x0131] = array(2, 0); // Software -> ASCII, Any |
||
| 2758 | $tags[0x0132] = array(2, 20); // DateTime -> ASCII, 20 |
||
| 2759 | $tags[0x013B] = array(2, 0); // Artist -> ASCII, Any |
||
| 2760 | $tags[0x013E] = array(5, 2); // WhitePoint -> RATIONAL, 2 |
||
| 2761 | $tags[0x013F] = array(5, 6); // PrimaryChromaticities -> RATIONAL, 6 |
||
| 2762 | $tags[0x0211] = array(5, 3); // YCbCrCoefficients -> RATIONAL, 3 |
||
| 2763 | $tags[0x0212] = array(3, 2); // YCbCrSubSampling -> SHORT, 2 |
||
| 2764 | $tags[0x0213] = array(3, 1); // YCbCrPositioning -> SHORT, 1 |
||
| 2765 | $tags[0x0214] = array(5, 6); // ReferenceBlackWhite -> RATIONAL, 6 |
||
| 2766 | $tags[0x8298] = array(2, 0); // Copyright -> ASCII, Any |
||
| 2767 | $tags[0x8769] = array(4, 1); // ExifIFDOffset -> LONG, 1 |
||
| 2768 | $tags[0x8825] = array(4, 1); // GPSIFDOffset -> LONG, 1 |
||
| 2769 | } |
||
| 2770 | if ($mode == 'ifd1') { |
||
| 2771 | $tags[0x00FE] = array(4, 1); // TIFFNewSubfileType -> LONG, 1 |
||
| 2772 | $tags[0x00FF] = array(3, 1); // TIFFSubfileType -> SHORT, 1 |
||
| 2773 | $tags[0x0100] = array(4, 1); // TIFFImageWidth -> LONG (or SHORT), 1 |
||
| 2774 | $tags[0x0101] = array(4, 1); // TIFFImageHeight -> LONG (or SHORT), 1 |
||
| 2775 | $tags[0x0102] = array(3, 3); // TIFFBitsPerSample -> SHORT, 3 |
||
| 2776 | $tags[0x0103] = array(3, 1); // TIFFCompression -> SHORT, 1 |
||
| 2777 | $tags[0x0106] = array(3, 1); // TIFFPhotometricInterpretation -> SHORT, 1 |
||
| 2778 | $tags[0x0107] = array(3, 1); // TIFFThreshholding -> SHORT, 1 |
||
| 2779 | $tags[0x0108] = array(3, 1); // TIFFCellWidth -> SHORT, 1 |
||
| 2780 | $tags[0x0109] = array(3, 1); // TIFFCellLength -> SHORT, 1 |
||
| 2781 | $tags[0x010A] = array(3, 1); // TIFFFillOrder -> SHORT, 1 |
||
| 2782 | $tags[0x010E] = array(2, 0); // TIFFImageDescription -> ASCII, Any |
||
| 2783 | $tags[0x010F] = array(2, 0); // TIFFMake -> ASCII, Any |
||
| 2784 | $tags[0x0110] = array(2, 0); // TIFFModel -> ASCII, Any |
||
| 2785 | $tags[0x0111] = array(4, 0); // TIFFStripOffsets -> LONG (or SHORT), Any (one per strip) |
||
| 2786 | $tags[0x0112] = array(3, 1); // TIFFOrientation -> SHORT, 1 |
||
| 2787 | $tags[0x0115] = array(3, 1); // TIFFSamplesPerPixel -> SHORT, 1 |
||
| 2788 | $tags[0x0116] = array(4, 1); // TIFFRowsPerStrip -> LONG (or SHORT), 1 |
||
| 2789 | $tags[0x0117] = array(4, 0); // TIFFStripByteCounts -> LONG (or SHORT), Any (one per strip) |
||
| 2790 | $tags[0x0118] = array(3, 0); // TIFFMinSampleValue -> SHORT, Any (SamplesPerPixel) |
||
| 2791 | $tags[0x0119] = array(3, 0); // TIFFMaxSampleValue -> SHORT, Any (SamplesPerPixel) |
||
| 2792 | $tags[0x011A] = array(5, 1); // TIFFXResolution -> RATIONAL, 1 |
||
| 2793 | $tags[0x011B] = array(5, 1); // TIFFYResolution -> RATIONAL, 1 |
||
| 2794 | $tags[0x011C] = array(3, 1); // TIFFPlanarConfiguration -> SHORT, 1 |
||
| 2795 | $tags[0x0122] = array(3, 1); // TIFFGrayResponseUnit -> SHORT, 1 |
||
| 2796 | $tags[0x0123] = array(3, 0); // TIFFGrayResponseCurve -> SHORT, Any (2^BitsPerSample) |
||
| 2797 | $tags[0x0128] = array(3, 1); // TIFFResolutionUnit -> SHORT, 1 |
||
| 2798 | $tags[0x0131] = array(2, 0); // TIFFSoftware -> ASCII, Any |
||
| 2799 | $tags[0x0132] = array(2, 20); // TIFFDateTime -> ASCII, 20 |
||
| 2800 | $tags[0x013B] = array(2, 0); // TIFFArtist -> ASCII, Any |
||
| 2801 | $tags[0x013C] = array(2, 0); // TIFFHostComputer -> ASCII, Any |
||
| 2802 | $tags[0x0140] = array(3, 0); // TIFFColorMap -> SHORT, Any (3 * 2^BitsPerSample) |
||
| 2803 | $tags[0x0152] = array(3, 0); // TIFFExtraSamples -> SHORT, Any (SamplesPerPixel - 3) |
||
| 2804 | $tags[0x0201] = array(4, 1); // TIFFJFIFOffset -> LONG, 1 |
||
| 2805 | $tags[0x0202] = array(4, 1); // TIFFJFIFLength -> LONG, 1 |
||
| 2806 | $tags[0x0211] = array(5, 3); // TIFFYCbCrCoefficients -> RATIONAL, 3 |
||
| 2807 | $tags[0x0212] = array(3, 2); // TIFFYCbCrSubSampling -> SHORT, 2 |
||
| 2808 | $tags[0x0213] = array(3, 1); // TIFFYCbCrPositioning -> SHORT, 1 |
||
| 2809 | $tags[0x0214] = array(5, 6); // TIFFReferenceBlackWhite -> RATIONAL, 6 |
||
| 2810 | $tags[0x8298] = array(2, 0); // TIFFCopyright -> ASCII, Any |
||
| 2811 | $tags[0x9286] = array(2, 0); // TIFFUserComment -> ASCII, Any |
||
| 2812 | } elseif ($mode == 'exif') { |
||
| 2813 | $tags[0x829A] = array(5, 1); // ExposureTime -> RATIONAL, 1 |
||
| 2814 | $tags[0x829D] = array(5, 1); // FNumber -> RATIONAL, 1 |
||
| 2815 | $tags[0x8822] = array(3, 1); // ExposureProgram -> SHORT, 1 |
||
| 2816 | $tags[0x8824] = array(2, 0); // SpectralSensitivity -> ASCII, Any |
||
| 2817 | $tags[0x8827] = array(3, 0); // ISOSpeedRatings -> SHORT, Any |
||
| 2818 | $tags[0x8828] = array(7, 0); // OECF -> UNDEFINED, Any |
||
| 2819 | $tags[0x9000] = array(7, 4); // EXIFVersion -> UNDEFINED, 4 |
||
| 2820 | $tags[0x9003] = array(2, 20); // DatetimeOriginal -> ASCII, 20 |
||
| 2821 | $tags[0x9004] = array(2, 20); // DatetimeDigitized -> ASCII, 20 |
||
| 2822 | $tags[0x9101] = array(7, 4); // ComponentsConfiguration -> UNDEFINED, 4 |
||
| 2823 | $tags[0x9102] = array(5, 1); // CompressedBitsPerPixel -> RATIONAL, 1 |
||
| 2824 | $tags[0x9201] = array(10, 1); // ShutterSpeedValue -> SRATIONAL, 1 |
||
| 2825 | $tags[0x9202] = array(5, 1); // ApertureValue -> RATIONAL, 1 |
||
| 2826 | $tags[0x9203] = array(10, 1); // BrightnessValue -> SRATIONAL, 1 |
||
| 2827 | $tags[0x9204] = array(10, 1); // ExposureBiasValue -> SRATIONAL, 1 |
||
| 2828 | $tags[0x9205] = array(5, 1); // MaxApertureValue -> RATIONAL, 1 |
||
| 2829 | $tags[0x9206] = array(5, 1); // SubjectDistance -> RATIONAL, 1 |
||
| 2830 | $tags[0x9207] = array(3, 1); // MeteringMode -> SHORT, 1 |
||
| 2831 | $tags[0x9208] = array(3, 1); // LightSource -> SHORT, 1 |
||
| 2832 | $tags[0x9209] = array(3, 1); // Flash -> SHORT, 1 |
||
| 2833 | $tags[0x920A] = array(5, 1); // FocalLength -> RATIONAL, 1 |
||
| 2834 | $tags[0x927C] = array(7, 0); // MakerNote -> UNDEFINED, Any |
||
| 2835 | $tags[0x9286] = array(7, 0); // UserComment -> UNDEFINED, Any |
||
| 2836 | $tags[0x9290] = array(2, 0); // SubSecTime -> ASCII, Any |
||
| 2837 | $tags[0x9291] = array(2, 0); // SubSecTimeOriginal -> ASCII, Any |
||
| 2838 | $tags[0x9292] = array(2, 0); // SubSecTimeDigitized -> ASCII, Any |
||
| 2839 | $tags[0xA000] = array(7, 4); // FlashPixVersion -> UNDEFINED, 4 |
||
| 2840 | $tags[0xA001] = array(3, 1); // ColorSpace -> SHORT, 1 |
||
| 2841 | $tags[0xA002] = array(4, 1); // PixelXDimension -> LONG (or SHORT), 1 |
||
| 2842 | $tags[0xA003] = array(4, 1); // PixelYDimension -> LONG (or SHORT), 1 |
||
| 2843 | $tags[0xA004] = array(2, 13); // RelatedSoundFile -> ASCII, 13 |
||
| 2844 | $tags[0xA005] = array(4, 1); // InteropIFDOffset -> LONG, 1 |
||
| 2845 | $tags[0xA20B] = array(5, 1); // FlashEnergy -> RATIONAL, 1 |
||
| 2846 | $tags[0xA20C] = array(7, 0); // SpatialFrequencyResponse -> UNDEFINED, Any |
||
| 2847 | $tags[0xA20E] = array(5, 1); // FocalPlaneXResolution -> RATIONAL, 1 |
||
| 2848 | $tags[0xA20F] = array(5, 1); // FocalPlaneYResolution -> RATIONAL, 1 |
||
| 2849 | $tags[0xA210] = array(3, 1); // FocalPlaneResolutionUnit -> SHORT, 1 |
||
| 2850 | $tags[0xA214] = array(3, 2); // SubjectLocation -> SHORT, 2 |
||
| 2851 | $tags[0xA215] = array(5, 1); // ExposureIndex -> RATIONAL, 1 |
||
| 2852 | $tags[0xA217] = array(3, 1); // SensingMethod -> SHORT, 1 |
||
| 2853 | $tags[0xA300] = array(7, 1); // FileSource -> UNDEFINED, 1 |
||
| 2854 | $tags[0xA301] = array(7, 1); // SceneType -> UNDEFINED, 1 |
||
| 2855 | $tags[0xA302] = array(7, 0); // CFAPattern -> UNDEFINED, Any |
||
| 2856 | } elseif ($mode == 'interop') { |
||
| 2857 | $tags[0x0001] = array(2, 0); // InteroperabilityIndex -> ASCII, Any |
||
| 2858 | $tags[0x0002] = array(7, 4); // InteroperabilityVersion -> UNKNOWN, 4 |
||
| 2859 | $tags[0x1000] = array(2, 0); // RelatedImageFileFormat -> ASCII, Any |
||
| 2860 | $tags[0x1001] = array(4, 1); // RelatedImageWidth -> LONG (or SHORT), 1 |
||
| 2861 | $tags[0x1002] = array(4, 1); // RelatedImageLength -> LONG (or SHORT), 1 |
||
| 2862 | } elseif ($mode == 'gps') { |
||
| 2863 | $tags[0x0000] = array(1, 4); // GPSVersionID -> BYTE, 4 |
||
| 2864 | $tags[0x0001] = array(2, 2); // GPSLatitudeRef -> ASCII, 2 |
||
| 2865 | $tags[0x0002] = array(5, 3); // GPSLatitude -> RATIONAL, 3 |
||
| 2866 | $tags[0x0003] = array(2, 2); // GPSLongitudeRef -> ASCII, 2 |
||
| 2867 | $tags[0x0004] = array(5, 3); // GPSLongitude -> RATIONAL, 3 |
||
| 2868 | $tags[0x0005] = array(2, 2); // GPSAltitudeRef -> ASCII, 2 |
||
| 2869 | $tags[0x0006] = array(5, 1); // GPSAltitude -> RATIONAL, 1 |
||
| 2870 | $tags[0x0007] = array(5, 3); // GPSTimeStamp -> RATIONAL, 3 |
||
| 2871 | $tags[0x0008] = array(2, 0); // GPSSatellites -> ASCII, Any |
||
| 2872 | $tags[0x0009] = array(2, 2); // GPSStatus -> ASCII, 2 |
||
| 2873 | $tags[0x000A] = array(2, 2); // GPSMeasureMode -> ASCII, 2 |
||
| 2874 | $tags[0x000B] = array(5, 1); // GPSDOP -> RATIONAL, 1 |
||
| 2875 | $tags[0x000C] = array(2, 2); // GPSSpeedRef -> ASCII, 2 |
||
| 2876 | $tags[0x000D] = array(5, 1); // GPSSpeed -> RATIONAL, 1 |
||
| 2877 | $tags[0x000E] = array(2, 2); // GPSTrackRef -> ASCII, 2 |
||
| 2878 | $tags[0x000F] = array(5, 1); // GPSTrack -> RATIONAL, 1 |
||
| 2879 | $tags[0x0010] = array(2, 2); // GPSImgDirectionRef -> ASCII, 2 |
||
| 2880 | $tags[0x0011] = array(5, 1); // GPSImgDirection -> RATIONAL, 1 |
||
| 2881 | $tags[0x0012] = array(2, 0); // GPSMapDatum -> ASCII, Any |
||
| 2882 | $tags[0x0013] = array(2, 2); // GPSDestLatitudeRef -> ASCII, 2 |
||
| 2883 | $tags[0x0014] = array(5, 3); // GPSDestLatitude -> RATIONAL, 3 |
||
| 2884 | $tags[0x0015] = array(2, 2); // GPSDestLongitudeRef -> ASCII, 2 |
||
| 2885 | $tags[0x0016] = array(5, 3); // GPSDestLongitude -> RATIONAL, 3 |
||
| 2886 | $tags[0x0017] = array(2, 2); // GPSDestBearingRef -> ASCII, 2 |
||
| 2887 | $tags[0x0018] = array(5, 1); // GPSDestBearing -> RATIONAL, 1 |
||
| 2888 | $tags[0x0019] = array(2, 2); // GPSDestDistanceRef -> ASCII, 2 |
||
| 2889 | $tags[0x001A] = array(5, 1); // GPSDestDistance -> RATIONAL, 1 |
||
| 2890 | } |
||
| 2891 | |||
| 2892 | return $tags; |
||
| 2893 | } |
||
| 2894 | |||
| 2895 | /*************************************************************/ |
||
| 2896 | function _exifNameTags($mode) { |
||
| 2900 | |||
| 2901 | /*************************************************************/ |
||
| 2902 | function _iptcTagNames() { |
||
| 2903 | $tags = array(); |
||
| 2904 | $tags[0x14] = 'SuplementalCategories'; |
||
| 2905 | $tags[0x19] = 'Keywords'; |
||
| 2906 | $tags[0x78] = 'Caption'; |
||
| 2907 | $tags[0x7A] = 'CaptionWriter'; |
||
| 2908 | $tags[0x69] = 'Headline'; |
||
| 2909 | $tags[0x28] = 'SpecialInstructions'; |
||
| 2910 | $tags[0x0F] = 'Category'; |
||
| 2911 | $tags[0x50] = 'Byline'; |
||
| 2912 | $tags[0x55] = 'BylineTitle'; |
||
| 2913 | $tags[0x6E] = 'Credit'; |
||
| 2914 | $tags[0x73] = 'Source'; |
||
| 2915 | $tags[0x74] = 'CopyrightNotice'; |
||
| 2916 | $tags[0x05] = 'ObjectName'; |
||
| 2917 | $tags[0x5A] = 'City'; |
||
| 2918 | $tags[0x5C] = 'Sublocation'; |
||
| 2919 | $tags[0x5F] = 'ProvinceState'; |
||
| 2920 | $tags[0x65] = 'CountryName'; |
||
| 2921 | $tags[0x67] = 'OriginalTransmissionReference'; |
||
| 2922 | $tags[0x37] = 'DateCreated'; |
||
| 2923 | $tags[0x0A] = 'CopyrightFlag'; |
||
| 2924 | |||
| 2925 | return $tags; |
||
| 2926 | } |
||
| 2927 | |||
| 2928 | /*************************************************************/ |
||
| 2929 | function & _iptcNameTags() { |
||
| 2933 | |||
| 2934 | /*************************************************************/ |
||
| 2935 | function _names2Tags($tags2Names) { |
||
| 2936 | $names2Tags = array(); |
||
| 2937 | reset($tags2Names); |
||
| 2938 | while (list($tag, $name) = each($tags2Names)) { |
||
| 2939 | $names2Tags[$name] = $tag; |
||
| 2940 | } |
||
| 2941 | |||
| 2942 | return $names2Tags; |
||
| 2943 | } |
||
| 2944 | |||
| 2945 | /*************************************************************/ |
||
| 2946 | |||
| 2947 | /** |
||
| 2948 | * @param integer $pos |
||
| 2949 | */ |
||
| 2950 | function _getByte(&$data, $pos) { |
||
| 2953 | |||
| 2954 | /*************************************************************/ |
||
| 2955 | |||
| 2956 | /** |
||
| 2957 | * @param integer $pos |
||
| 2958 | */ |
||
| 2959 | function _putByte(&$data, $pos, $val) { |
||
| 2960 | $val = intval($val); |
||
| 2961 | |||
| 2962 | $data{$pos} = chr($val); |
||
| 2963 | |||
| 2964 | return $pos + 1; |
||
| 2965 | } |
||
| 2966 | |||
| 2967 | /*************************************************************/ |
||
| 2968 | function _getShort(&$data, $pos, $bigEndian = true) { |
||
| 2969 | if ($bigEndian) { |
||
| 2970 | return (ord($data{$pos}) << 8) |
||
| 2971 | + ord($data{$pos + 1}); |
||
| 2972 | } else { |
||
| 2973 | return ord($data{$pos}) |
||
| 2974 | + (ord($data{$pos + 1}) << 8); |
||
| 2975 | } |
||
| 2976 | } |
||
| 2977 | |||
| 2978 | /*************************************************************/ |
||
| 2979 | function _putShort(&$data, $pos = 0, $val = 0, $bigEndian = true) { |
||
| 2980 | $val = intval($val); |
||
| 2981 | |||
| 2982 | if ($bigEndian) { |
||
| 2983 | $data{$pos + 0} = chr(($val & 0x0000FF00) >> 8); |
||
| 2984 | $data{$pos + 1} = chr(($val & 0x000000FF) >> 0); |
||
| 2985 | } else { |
||
| 2986 | $data{$pos + 0} = chr(($val & 0x00FF) >> 0); |
||
| 2987 | $data{$pos + 1} = chr(($val & 0xFF00) >> 8); |
||
| 2988 | } |
||
| 2989 | |||
| 2990 | return $pos + 2; |
||
| 2991 | } |
||
| 2992 | |||
| 2993 | /*************************************************************/ |
||
| 2994 | |||
| 2995 | /** |
||
| 2996 | * @param integer $pos |
||
| 2997 | */ |
||
| 2998 | function _getLong(&$data, $pos, $bigEndian = true) { |
||
| 3011 | |||
| 3012 | /*************************************************************/ |
||
| 3013 | |||
| 3014 | /** |
||
| 3015 | * @param integer $pos |
||
| 3016 | */ |
||
| 3017 | function _putLong(&$data, $pos, $val, $bigEndian = true) { |
||
| 3034 | |||
| 3035 | /*************************************************************/ |
||
| 3036 | function & _getNullString(&$data, $pos) { |
||
| 3051 | |||
| 3052 | /*************************************************************/ |
||
| 3053 | function & _getFixedString(&$data, $pos, $length = -1) { |
||
| 3061 | |||
| 3062 | /*************************************************************/ |
||
| 3063 | function _putString(&$data, $pos, &$str) { |
||
| 3071 | |||
| 3072 | /*************************************************************/ |
||
| 3073 | function _hexDump(&$data, $start = 0, $length = -1) { |
||
| 3133 | |||
| 3134 | /*****************************************************************/ |
||
| 3135 | } |
||
| 3136 | |||
| 3138 |
Loading history...
Adding explicit visibility (
private,protected, orpublic) is generally recommend to communicate to other developers how, and from where this method is intended to be used.