xref: /dokuwiki/inc/JpegMeta.php (revision 38afa93051a45a1719a429b69b9275e317a70da6) 
1<?php
2/**
3 * JPEG metadata reader/writer
4 *
5 * @license    BSD <http://www.opensource.org/licenses/bsd-license.php>
6 * @link       http://github.com/sd/jpeg-php
7 * @author     Sebastian Delmont <sdelmont@zonageek.com>
8 * @author     Andreas Gohr <andi@splitbrain.org>
9 * @author     Hakan Sandell <hakan.sandell@mydata.se>
10 * @todo       Add support for Maker Notes, Extend for GIF and PNG metadata
11 */
12
13// Original copyright notice:
14//
15// Copyright (c) 2003 Sebastian Delmont <sdelmont@zonageek.com>
16// All rights reserved.
17//
18// Redistribution and use in source and binary forms, with or without
19// modification, are permitted provided that the following conditions
20// are met:
21// 1. Redistributions of source code must retain the above copyright
22//    notice, this list of conditions and the following disclaimer.
23// 2. Redistributions in binary form must reproduce the above copyright
24//    notice, this list of conditions and the following disclaimer in the
25//    documentation and/or other materials provided with the distribution.
26// 3. Neither the name of the author nor the names of its contributors
27//    may be used to endorse or promote products derived from this software
28//    without specific prior written permission.
29//
30// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
31// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
32// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
33// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
34// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
35// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
36// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
37// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
38// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
39// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
40// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
41
42class 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 <sdelmont@zonageek.com>
56     *
57     * @param $fileName
58     */
59    function __construct($fileName) {
60
61        $this->_fileName = $fileName;
62
63        $this->_fp = null;
64        $this->_type = 'unknown';
65
66        unset($this->_info);
67        unset($this->_markers);
68    }
69
70    /**
71     * Returns all gathered info as multidim array
72     *
73     * @author Sebastian Delmont <sdelmont@zonageek.com>
74     */
75    function & getRawInfo() {
76        $this->_parseAll();
77
78        if ($this->_markers == null) {
79            return false;
80        }
81
82        return $this->_info;
83    }
84
85    /**
86     * Returns basic image info
87     *
88     * @author Sebastian Delmont <sdelmont@zonageek.com>
89     */
90    function & getBasicInfo() {
91        $this->_parseAll();
92
93        $info = array();
94
95        if ($this->_markers == null) {
96            return false;
97        }
98
99        $info['Name'] = $this->_info['file']['Name'];
100        if (isset($this->_info['file']['Url'])) {
101            $info['Url'] = $this->_info['file']['Url'];
102            $info['NiceSize'] = "???KB";
103        } else {
104            $info['Size'] = $this->_info['file']['Size'];
105            $info['NiceSize'] = $this->_info['file']['NiceSize'];
106        }
107
108        if (@isset($this->_info['sof']['Format'])) {
109            $info['Format'] = $this->_info['sof']['Format'] . " JPEG";
110        } else {
111            $info['Format'] = $this->_info['sof']['Format'] . " JPEG";
112        }
113
114        if (@isset($this->_info['sof']['ColorChannels'])) {
115            $info['ColorMode'] = ($this->_info['sof']['ColorChannels'] > 1) ? "Color" : "B&W";
116        }
117
118        $info['Width'] = $this->getWidth();
119        $info['Height'] = $this->getHeight();
120        $info['DimStr'] = $this->getDimStr();
121
122        $dates = $this->getDates();
123
124        $info['DateTime'] = $dates['EarliestTime'];
125        $info['DateTimeStr'] = $dates['EarliestTimeStr'];
126
127        $info['HasThumbnail'] = $this->hasThumbnail();
128
129        return $info;
130    }
131
132
133    /**
134     * Convinience function to access nearly all available Data
135     * through one function
136     *
137     * @author Andreas Gohr <andi@splitbrain.org>
138     *
139     * @param array|string $fields field name or array with field names
140     * @return bool|string
141     */
142    function getField($fields) {
143        if(!is_array($fields)) $fields = array($fields);
144        $info = false;
145        foreach($fields as $field){
146            if(strtolower(substr($field,0,5)) == 'iptc.'){
147                $info = $this->getIPTCField(substr($field,5));
148            }elseif(strtolower(substr($field,0,5)) == 'exif.'){
149                $info = $this->getExifField(substr($field,5));
150            }elseif(strtolower(substr($field,0,4)) == 'xmp.'){
151                $info = $this->getXmpField(substr($field,4));
152            }elseif(strtolower(substr($field,0,5)) == 'file.'){
153                $info = $this->getFileField(substr($field,5));
154            }elseif(strtolower(substr($field,0,5)) == 'date.'){
155                $info = $this->getDateField(substr($field,5));
156            }elseif(strtolower($field) == 'simple.camera'){
157                $info = $this->getCamera();
158            }elseif(strtolower($field) == 'simple.raw'){
159                return $this->getRawInfo();
160            }elseif(strtolower($field) == 'simple.title'){
161                $info = $this->getTitle();
162            }elseif(strtolower($field) == 'simple.shutterspeed'){
163                $info = $this->getShutterSpeed();
164            }else{
165                $info = $this->getExifField($field);
166            }
167            if($info != false) break;
168        }
169
170        if($info === false)  $info = '';
171        if(is_array($info)){
172            if(isset($info['val'])){
173                $info = $info['val'];
174            }else{
175                $arr = array();
176                foreach($info as $part){
177                    if(is_array($part)){
178                        if(isset($part['val'])){
179                            $arr[] = $part['val'];
180                        }else{
181                            $arr[] = join(', ',$part);
182                        }
183                    }else{
184                        $arr[] = $part;
185                    }
186                }
187                $info = join(', ',$arr);
188            }
189        }
190        return trim($info);
191    }
192
193    /**
194     * Convinience function to set nearly all available Data
195     * through one function
196     *
197     * @author Andreas Gohr <andi@splitbrain.org>
198     *
199     * @param string $field field name
200     * @param string $value
201     * @return bool success or fail
202     */
203    function setField($field, $value) {
204        if(strtolower(substr($field,0,5)) == 'iptc.'){
205            return $this->setIPTCField(substr($field,5),$value);
206        }elseif(strtolower(substr($field,0,5)) == 'exif.'){
207            return $this->setExifField(substr($field,5),$value);
208        }else{
209            return $this->setExifField($field,$value);
210        }
211    }
212
213    /**
214     * Convinience function to delete nearly all available Data
215     * through one function
216     *
217     * @author Andreas Gohr <andi@splitbrain.org>
218     *
219     * @param string $field field name
220     * @return bool
221     */
222    function deleteField($field) {
223        if(strtolower(substr($field,0,5)) == 'iptc.'){
224            return $this->deleteIPTCField(substr($field,5));
225        }elseif(strtolower(substr($field,0,5)) == 'exif.'){
226            return $this->deleteExifField(substr($field,5));
227        }else{
228            return $this->deleteExifField($field);
229        }
230    }
231
232    /**
233     * Return a date field
234     *
235     * @author Andreas Gohr <andi@splitbrain.org>
236     *
237     * @param string $field
238     * @return false|string
239     */
240    function getDateField($field) {
241        if (!isset($this->_info['dates'])) {
242            $this->_info['dates'] = $this->getDates();
243        }
244
245        if (isset($this->_info['dates'][$field])) {
246            return $this->_info['dates'][$field];
247        }
248
249        return false;
250    }
251
252    /**
253     * Return a file info field
254     *
255     * @author Andreas Gohr <andi@splitbrain.org>
256     *
257     * @param string $field field name
258     * @return false|string
259     */
260    function getFileField($field) {
261        if (!isset($this->_info['file'])) {
262            $this->_parseFileInfo();
263        }
264
265        if (isset($this->_info['file'][$field])) {
266            return $this->_info['file'][$field];
267        }
268
269        return false;
270    }
271
272    /**
273     * Return the camera info (Maker and Model)
274     *
275     * @author Andreas Gohr <andi@splitbrain.org>
276     * @todo   handle makernotes
277     *
278     * @return false|string
279     */
280    function getCamera(){
281        $make  = $this->getField(array('Exif.Make','Exif.TIFFMake'));
282        $model = $this->getField(array('Exif.Model','Exif.TIFFModel'));
283        $cam = trim("$make $model");
284        if(empty($cam)) return false;
285        return $cam;
286    }
287
288    /**
289     * Return shutter speed as a ratio
290     *
291     * @author Joe Lapp <joe.lapp@pobox.com>
292     *
293     * @return string
294     */
295    function getShutterSpeed() {
296        if (!isset($this->_info['exif'])) {
297            $this->_parseMarkerExif();
298        }
299        if(!isset($this->_info['exif']['ExposureTime'])){
300            return '';
301        }
302
303        $field = $this->_info['exif']['ExposureTime'];
304        if($field['den'] == 1) return $field['num'];
305        return $field['num'].'/'.$field['den'];
306    }
307
308    /**
309     * Return an EXIF field
310     *
311     * @author Sebastian Delmont <sdelmont@zonageek.com>
312     *
313     * @param string $field field name
314     * @return false|string
315     */
316    function getExifField($field) {
317        if (!isset($this->_info['exif'])) {
318            $this->_parseMarkerExif();
319        }
320
321        if ($this->_markers == null) {
322            return false;
323        }
324
325        if (isset($this->_info['exif'][$field])) {
326            return $this->_info['exif'][$field];
327        }
328
329        return false;
330    }
331
332    /**
333     * Return an XMP field
334     *
335     * @author Hakan Sandell <hakan.sandell@mydata.se>
336     *
337     * @param string $field field name
338     * @return false|string
339     */
340    function getXmpField($field) {
341        if (!isset($this->_info['xmp'])) {
342            $this->_parseMarkerXmp();
343        }
344
345        if ($this->_markers == null) {
346            return false;
347        }
348
349        if (isset($this->_info['xmp'][$field])) {
350            return $this->_info['xmp'][$field];
351        }
352
353        return false;
354    }
355
356    /**
357     * Return an Adobe Field
358     *
359     * @author Sebastian Delmont <sdelmont@zonageek.com>
360     *
361     * @param string $field field name
362     * @return false|string
363     */
364    function getAdobeField($field) {
365        if (!isset($this->_info['adobe'])) {
366            $this->_parseMarkerAdobe();
367        }
368
369        if ($this->_markers == null) {
370            return false;
371        }
372
373        if (isset($this->_info['adobe'][$field])) {
374            return $this->_info['adobe'][$field];
375        }
376
377        return false;
378    }
379
380    /**
381     * Return an IPTC field
382     *
383     * @author Sebastian Delmont <sdelmont@zonageek.com>
384     *
385     * @param string $field field name
386     * @return false|string
387     */
388    function getIPTCField($field) {
389        if (!isset($this->_info['iptc'])) {
390            $this->_parseMarkerAdobe();
391        }
392
393        if ($this->_markers == null) {
394            return false;
395        }
396
397        if (isset($this->_info['iptc'][$field])) {
398            return $this->_info['iptc'][$field];
399        }
400
401        return false;
402    }
403
404    /**
405     * Set an EXIF field
406     *
407     * @author Sebastian Delmont <sdelmont@zonageek.com>
408     * @author Joe Lapp <joe.lapp@pobox.com>
409     *
410     * @param string $field field name
411     * @param string $value
412     * @return bool
413     */
414    function setExifField($field, $value) {
415        if (!isset($this->_info['exif'])) {
416            $this->_parseMarkerExif();
417        }
418
419        if ($this->_markers == null) {
420            return false;
421        }
422
423        if ($this->_info['exif'] == false) {
424            $this->_info['exif'] = array();
425        }
426
427        // make sure datetimes are in correct format
428        if(strlen($field) >= 8 && strtolower(substr($field, 0, 8)) == 'datetime') {
429            if(strlen($value) < 8 || $value[4] != ':' || $value[7] != ':') {
430                $value = date('Y:m:d H:i:s', strtotime($value));
431            }
432        }
433
434        $this->_info['exif'][$field] = $value;
435
436        return true;
437    }
438
439    /**
440     * Set an Adobe Field
441     *
442     * @author Sebastian Delmont <sdelmont@zonageek.com>
443     *
444     * @param string $field field name
445     * @param string $value
446     * @return bool
447     */
448    function setAdobeField($field, $value) {
449        if (!isset($this->_info['adobe'])) {
450            $this->_parseMarkerAdobe();
451        }
452
453        if ($this->_markers == null) {
454            return false;
455        }
456
457        if ($this->_info['adobe'] == false) {
458            $this->_info['adobe'] = array();
459        }
460
461        $this->_info['adobe'][$field] = $value;
462
463        return true;
464    }
465
466    /**
467     * Calculates the multiplier needed to resize the image to the given
468     * dimensions
469     *
470     * @author Andreas Gohr <andi@splitbrain.org>
471     *
472     * @param int $maxwidth
473     * @param int $maxheight
474     * @return float|int
475     */
476    function getResizeRatio($maxwidth,$maxheight=0){
477        if(!$maxheight) $maxheight = $maxwidth;
478
479        $w = $this->getField('File.Width');
480        $h = $this->getField('File.Height');
481
482        $ratio = 1;
483        if($w >= $h){
484            if($w >= $maxwidth){
485                $ratio = $maxwidth/$w;
486            }elseif($h > $maxheight){
487                $ratio = $maxheight/$h;
488            }
489        }else{
490            if($h >= $maxheight){
491                $ratio = $maxheight/$h;
492            }elseif($w > $maxwidth){
493                $ratio = $maxwidth/$w;
494            }
495        }
496        return $ratio;
497    }
498
499
500    /**
501     * Set an IPTC field
502     *
503     * @author Sebastian Delmont <sdelmont@zonageek.com>
504     *
505     * @param string $field field name
506     * @param string $value
507     * @return bool
508     */
509    function setIPTCField($field, $value) {
510        if (!isset($this->_info['iptc'])) {
511            $this->_parseMarkerAdobe();
512        }
513
514        if ($this->_markers == null) {
515            return false;
516        }
517
518        if ($this->_info['iptc'] == false) {
519            $this->_info['iptc'] = array();
520        }
521
522        $this->_info['iptc'][$field] = $value;
523
524        return true;
525    }
526
527    /**
528     * Delete an EXIF field
529     *
530     * @author Sebastian Delmont <sdelmont@zonageek.com>
531     *
532     * @param string $field field name
533     * @return bool
534     */
535    function deleteExifField($field) {
536        if (!isset($this->_info['exif'])) {
537            $this->_parseMarkerAdobe();
538        }
539
540        if ($this->_markers == null) {
541            return false;
542        }
543
544        if ($this->_info['exif'] != false) {
545            unset($this->_info['exif'][$field]);
546        }
547
548        return true;
549    }
550
551    /**
552     * Delete an Adobe field
553     *
554     * @author Sebastian Delmont <sdelmont@zonageek.com>
555     *
556     * @param string $field field name
557     * @return bool
558     */
559    function deleteAdobeField($field) {
560        if (!isset($this->_info['adobe'])) {
561            $this->_parseMarkerAdobe();
562        }
563
564        if ($this->_markers == null) {
565            return false;
566        }
567
568        if ($this->_info['adobe'] != false) {
569            unset($this->_info['adobe'][$field]);
570        }
571
572        return true;
573    }
574
575    /**
576     * Delete an IPTC field
577     *
578     * @author Sebastian Delmont <sdelmont@zonageek.com>
579     *
580     * @param string $field field name
581     * @return bool
582     */
583    function deleteIPTCField($field) {
584        if (!isset($this->_info['iptc'])) {
585            $this->_parseMarkerAdobe();
586        }
587
588        if ($this->_markers == null) {
589            return false;
590        }
591
592        if ($this->_info['iptc'] != false) {
593            unset($this->_info['iptc'][$field]);
594        }
595
596        return true;
597    }
598
599    /**
600     * Get the image's title, tries various fields
601     *
602     * @param int $max maximum number chars (keeps words)
603     * @return false|string
604     *
605     * @author Andreas Gohr <andi@splitbrain.org>
606     */
607    function getTitle($max=80){
608        // try various fields
609        $cap = $this->getField(array('Iptc.Headline',
610                    'Iptc.Caption',
611                    'Xmp.dc:title',
612                    'Exif.UserComment',
613                    'Exif.TIFFUserComment',
614                    'Exif.TIFFImageDescription',
615                    'File.Name'));
616        if (empty($cap)) return false;
617
618        if(!$max) return $cap;
619        // Shorten to 80 chars (keeping words)
620        $new = preg_replace('/\n.+$/','',wordwrap($cap, $max));
621        if($new != $cap) $new .= '...';
622
623        return $new;
624    }
625
626    /**
627     * Gather various date fields
628     *
629     * @author Sebastian Delmont <sdelmont@zonageek.com>
630     *
631     * @return array|bool
632     */
633    function getDates() {
634        $this->_parseAll();
635        if ($this->_markers == null) {
636            if (@isset($this->_info['file']['UnixTime'])) {
637                $dates = array();
638                $dates['FileModified'] = $this->_info['file']['UnixTime'];
639                $dates['Time'] = $this->_info['file']['UnixTime'];
640                $dates['TimeSource'] = 'FileModified';
641                $dates['TimeStr'] = date("Y-m-d H:i:s", $this->_info['file']['UnixTime']);
642                $dates['EarliestTime'] = $this->_info['file']['UnixTime'];
643                $dates['EarliestTimeSource'] = 'FileModified';
644                $dates['EarliestTimeStr'] = date("Y-m-d H:i:s", $this->_info['file']['UnixTime']);
645                $dates['LatestTime'] = $this->_info['file']['UnixTime'];
646                $dates['LatestTimeSource'] = 'FileModified';
647                $dates['LatestTimeStr'] = date("Y-m-d H:i:s", $this->_info['file']['UnixTime']);
648                return $dates;
649            }
650            return false;
651        }
652
653        $dates = array();
654
655        $latestTime = 0;
656        $latestTimeSource = "";
657        $earliestTime = time();
658        $earliestTimeSource = "";
659
660        if (@isset($this->_info['exif']['DateTime'])) {
661            $dates['ExifDateTime'] = $this->_info['exif']['DateTime'];
662
663            $aux = $this->_info['exif']['DateTime'];
664            $aux[4] = "-";
665            $aux[7] = "-";
666            $t = strtotime($aux);
667
668            if ($t && $t > $latestTime) {
669                $latestTime = $t;
670                $latestTimeSource = "ExifDateTime";
671            }
672
673            if ($t && $t < $earliestTime) {
674                $earliestTime = $t;
675                $earliestTimeSource = "ExifDateTime";
676            }
677        }
678
679        if (@isset($this->_info['exif']['DateTimeOriginal'])) {
680            $dates['ExifDateTimeOriginal'] = $this->_info['exif']['DateTimeOriginal'];
681
682            $aux = $this->_info['exif']['DateTimeOriginal'];
683            $aux[4] = "-";
684            $aux[7] = "-";
685            $t = strtotime($aux);
686
687            if ($t && $t > $latestTime) {
688                $latestTime = $t;
689                $latestTimeSource = "ExifDateTimeOriginal";
690            }
691
692            if ($t && $t < $earliestTime) {
693                $earliestTime = $t;
694                $earliestTimeSource = "ExifDateTimeOriginal";
695            }
696        }
697
698        if (@isset($this->_info['exif']['DateTimeDigitized'])) {
699            $dates['ExifDateTimeDigitized'] = $this->_info['exif']['DateTimeDigitized'];
700
701            $aux = $this->_info['exif']['DateTimeDigitized'];
702            $aux[4] = "-";
703            $aux[7] = "-";
704            $t = strtotime($aux);
705
706            if ($t && $t > $latestTime) {
707                $latestTime = $t;
708                $latestTimeSource = "ExifDateTimeDigitized";
709            }
710
711            if ($t && $t < $earliestTime) {
712                $earliestTime = $t;
713                $earliestTimeSource = "ExifDateTimeDigitized";
714            }
715        }
716
717        if (@isset($this->_info['iptc']['DateCreated'])) {
718            $dates['IPTCDateCreated'] = $this->_info['iptc']['DateCreated'];
719
720            $aux = $this->_info['iptc']['DateCreated'];
721            $aux = substr($aux, 0, 4) . "-" . substr($aux, 4, 2) . "-" . substr($aux, 6, 2);
722            $t = strtotime($aux);
723
724            if ($t && $t > $latestTime) {
725                $latestTime = $t;
726                $latestTimeSource = "IPTCDateCreated";
727            }
728
729            if ($t && $t < $earliestTime) {
730                $earliestTime = $t;
731                $earliestTimeSource = "IPTCDateCreated";
732            }
733        }
734
735        if (@isset($this->_info['file']['UnixTime'])) {
736            $dates['FileModified'] = $this->_info['file']['UnixTime'];
737
738            $t = $this->_info['file']['UnixTime'];
739
740            if ($t && $t > $latestTime) {
741                $latestTime = $t;
742                $latestTimeSource = "FileModified";
743            }
744
745            if ($t && $t < $earliestTime) {
746                $earliestTime = $t;
747                $earliestTimeSource = "FileModified";
748            }
749        }
750
751        $dates['Time'] = $earliestTime;
752        $dates['TimeSource'] = $earliestTimeSource;
753        $dates['TimeStr'] = date("Y-m-d H:i:s", $earliestTime);
754        $dates['EarliestTime'] = $earliestTime;
755        $dates['EarliestTimeSource'] = $earliestTimeSource;
756        $dates['EarliestTimeStr'] = date("Y-m-d H:i:s", $earliestTime);
757        $dates['LatestTime'] = $latestTime;
758        $dates['LatestTimeSource'] = $latestTimeSource;
759        $dates['LatestTimeStr'] = date("Y-m-d H:i:s", $latestTime);
760
761        return $dates;
762    }
763
764    /**
765     * Get the image width, tries various fields
766     *
767     * @author Sebastian Delmont <sdelmont@zonageek.com>
768     *
769     * @return false|string
770     */
771    function getWidth() {
772        if (!isset($this->_info['sof'])) {
773            $this->_parseMarkerSOF();
774        }
775
776        if ($this->_markers == null) {
777            return false;
778        }
779
780        if (isset($this->_info['sof']['ImageWidth'])) {
781            return $this->_info['sof']['ImageWidth'];
782        }
783
784        if (!isset($this->_info['exif'])) {
785            $this->_parseMarkerExif();
786        }
787
788        if (isset($this->_info['exif']['PixelXDimension'])) {
789            return $this->_info['exif']['PixelXDimension'];
790        }
791
792        return false;
793    }
794
795    /**
796     * Get the image height, tries various fields
797     *
798     * @author Sebastian Delmont <sdelmont@zonageek.com>
799     *
800     * @return false|string
801     */
802    function getHeight() {
803        if (!isset($this->_info['sof'])) {
804            $this->_parseMarkerSOF();
805        }
806
807        if ($this->_markers == null) {
808            return false;
809        }
810
811        if (isset($this->_info['sof']['ImageHeight'])) {
812            return $this->_info['sof']['ImageHeight'];
813        }
814
815        if (!isset($this->_info['exif'])) {
816            $this->_parseMarkerExif();
817        }
818
819        if (isset($this->_info['exif']['PixelYDimension'])) {
820            return $this->_info['exif']['PixelYDimension'];
821        }
822
823        return false;
824    }
825
826    /**
827     * Get an dimension string for use in img tag
828     *
829     * @author Sebastian Delmont <sdelmont@zonageek.com>
830     *
831     * @return false|string
832     */
833    function getDimStr() {
834        if ($this->_markers == null) {
835            return false;
836        }
837
838        $w = $this->getWidth();
839        $h = $this->getHeight();
840
841        return "width='" . $w . "' height='" . $h . "'";
842    }
843
844    /**
845     * Checks for an embedded thumbnail
846     *
847     * @author Sebastian Delmont <sdelmont@zonageek.com>
848     *
849     * @param string $which possible values: 'any', 'exif' or 'adobe'
850     * @return false|string
851     */
852    function hasThumbnail($which = 'any') {
853        if (($which == 'any') || ($which == 'exif')) {
854            if (!isset($this->_info['exif'])) {
855                $this->_parseMarkerExif();
856            }
857
858            if ($this->_markers == null) {
859                return false;
860            }
861
862            if (isset($this->_info['exif']) && is_array($this->_info['exif'])) {
863                if (isset($this->_info['exif']['JFIFThumbnail'])) {
864                    return 'exif';
865                }
866            }
867        }
868
869        if ($which == 'adobe') {
870            if (!isset($this->_info['adobe'])) {
871                $this->_parseMarkerAdobe();
872            }
873
874            if ($this->_markers == null) {
875                return false;
876            }
877
878            if (isset($this->_info['adobe']) && is_array($this->_info['adobe'])) {
879                if (isset($this->_info['adobe']['ThumbnailData'])) {
880                    return 'exif';
881                }
882            }
883        }
884
885        return false;
886    }
887
888    /**
889     * Send embedded thumbnail to browser
890     *
891     * @author Sebastian Delmont <sdelmont@zonageek.com>
892     *
893     * @param string $which possible values: 'any', 'exif' or 'adobe'
894     * @return bool
895     */
896    function sendThumbnail($which = 'any') {
897        $data = null;
898
899        if (($which == 'any') || ($which == 'exif')) {
900            if (!isset($this->_info['exif'])) {
901                $this->_parseMarkerExif();
902            }
903
904            if ($this->_markers == null) {
905                return false;
906            }
907
908            if (isset($this->_info['exif']) && is_array($this->_info['exif'])) {
909                if (isset($this->_info['exif']['JFIFThumbnail'])) {
910                    $data =& $this->_info['exif']['JFIFThumbnail'];
911                }
912            }
913        }
914
915        if (($which == 'adobe') || ($data == null)){
916            if (!isset($this->_info['adobe'])) {
917                $this->_parseMarkerAdobe();
918            }
919
920            if ($this->_markers == null) {
921                return false;
922            }
923
924            if (isset($this->_info['adobe']) && is_array($this->_info['adobe'])) {
925                if (isset($this->_info['adobe']['ThumbnailData'])) {
926                    $data =& $this->_info['adobe']['ThumbnailData'];
927                }
928            }
929        }
930
931        if ($data != null) {
932            header("Content-type: image/jpeg");
933            echo $data;
934            return true;
935        }
936
937        return false;
938    }
939
940    /**
941     * Save changed Metadata
942     *
943     * @author Sebastian Delmont <sdelmont@zonageek.com>
944     * @author Andreas Gohr <andi@splitbrain.org>
945     *
946     * @param string $fileName file name or empty string for a random name
947     * @return bool
948     */
949    function save($fileName = "") {
950        if ($fileName == "") {
951            $tmpName = tempnam(dirname($this->_fileName),'_metatemp_');
952            $this->_writeJPEG($tmpName);
953            if (file_exists($tmpName)) {
954                return io_rename($tmpName, $this->_fileName);
955            }
956        } else {
957            return $this->_writeJPEG($fileName);
958        }
959        return false;
960    }
961
962    /*************************************************************/
963    /* PRIVATE FUNCTIONS (Internal Use Only!)                    */
964    /*************************************************************/
965
966    /*************************************************************/
967    function _dispose($fileName = "") {
968        $this->_fileName = $fileName;
969
970        $this->_fp = null;
971        $this->_type = 'unknown';
972
973        unset($this->_markers);
974        unset($this->_info);
975    }
976
977    /*************************************************************/
978    function _readJPEG() {
979        unset($this->_markers);
980        //unset($this->_info);
981        $this->_markers = array();
982        //$this->_info = array();
983
984        $this->_fp = @fopen($this->_fileName, 'rb');
985        if ($this->_fp) {
986            if (file_exists($this->_fileName)) {
987                $this->_type = 'file';
988            }
989            else {
990                $this->_type = 'url';
991            }
992        } else {
993            $this->_fp = null;
994            return false;  // ERROR: Can't open file
995        }
996
997        // Check for the JPEG signature
998        $c1 = ord(fgetc($this->_fp));
999        $c2 = ord(fgetc($this->_fp));
1000
1001        if ($c1 != 0xFF || $c2 != 0xD8) {   // (0xFF + SOI)
1002            $this->_markers = null;
1003            return false;  // ERROR: File is not a JPEG
1004        }
1005
1006        $count = 0;
1007
1008        $done = false;
1009        $ok = true;
1010
1011        while (!$done) {
1012            $capture = false;
1013
1014            // First, skip any non 0xFF bytes
1015            $discarded = 0;
1016            $c = ord(fgetc($this->_fp));
1017            while (!feof($this->_fp) && ($c != 0xFF)) {
1018                $discarded++;
1019                $c = ord(fgetc($this->_fp));
1020            }
1021            // Then skip all 0xFF until the marker byte
1022            do {
1023                $marker = ord(fgetc($this->_fp));
1024            } while (!feof($this->_fp) && ($marker == 0xFF));
1025
1026            if (feof($this->_fp)) {
1027                return false; // ERROR: Unexpected EOF
1028            }
1029            if ($discarded != 0) {
1030                return false; // ERROR: Extraneous data
1031            }
1032
1033            $length = ord(fgetc($this->_fp)) * 256 + ord(fgetc($this->_fp));
1034            if (feof($this->_fp)) {
1035                return false; // ERROR: Unexpected EOF
1036            }
1037            if ($length < 2) {
1038                return false; // ERROR: Extraneous data
1039            }
1040            $length = $length - 2; // The length we got counts itself
1041
1042            switch ($marker) {
1043                case 0xC0:    // SOF0
1044                case 0xC1:    // SOF1
1045                case 0xC2:    // SOF2
1046                case 0xC9:    // SOF9
1047                case 0xE0:    // APP0: JFIF data
1048                case 0xE1:    // APP1: EXIF or XMP data
1049                case 0xED:    // APP13: IPTC / Photoshop data
1050                    $capture = true;
1051                    break;
1052                case 0xDA:    // SOS: Start of scan... the image itself and the last block on the file
1053                    $capture = false;
1054                    $length = -1;  // This field has no length... it includes all data until EOF
1055                    $done = true;
1056                    break;
1057                default:
1058                    $capture = true;//false;
1059                    break;
1060            }
1061
1062            $this->_markers[$count] = array();
1063            $this->_markers[$count]['marker'] = $marker;
1064            $this->_markers[$count]['length'] = $length;
1065
1066            if ($capture) {
1067                if ($length)
1068                    $this->_markers[$count]['data'] = fread($this->_fp, $length);
1069                else
1070                    $this->_markers[$count]['data'] = "";
1071            }
1072            elseif (!$done) {
1073                $result = @fseek($this->_fp, $length, SEEK_CUR);
1074                // fseek doesn't seem to like HTTP 'files', but fgetc has no problem
1075                if (!($result === 0)) {
1076                    for ($i = 0; $i < $length; $i++) {
1077                        fgetc($this->_fp);
1078                    }
1079                }
1080            }
1081            $count++;
1082        }
1083
1084        if ($this->_fp) {
1085            fclose($this->_fp);
1086            $this->_fp = null;
1087        }
1088
1089        return $ok;
1090    }
1091
1092    /*************************************************************/
1093    function _parseAll() {
1094        if (!isset($this->_info['file'])) {
1095            $this->_parseFileInfo();
1096        }
1097        if (!isset($this->_markers)) {
1098            $this->_readJPEG();
1099        }
1100
1101        if ($this->_markers == null) {
1102            return false;
1103        }
1104
1105        if (!isset($this->_info['jfif'])) {
1106            $this->_parseMarkerJFIF();
1107        }
1108        if (!isset($this->_info['jpeg'])) {
1109            $this->_parseMarkerSOF();
1110        }
1111        if (!isset($this->_info['exif'])) {
1112            $this->_parseMarkerExif();
1113        }
1114        if (!isset($this->_info['xmp'])) {
1115            $this->_parseMarkerXmp();
1116        }
1117        if (!isset($this->_info['adobe'])) {
1118            $this->_parseMarkerAdobe();
1119        }
1120    }
1121
1122    /*************************************************************/
1123
1124    /**
1125     * @param string $outputName
1126     *
1127     * @return bool
1128     */
1129    function _writeJPEG($outputName) {
1130        $this->_parseAll();
1131
1132        $wroteEXIF = false;
1133        $wroteAdobe = false;
1134
1135        $this->_fp = @fopen($this->_fileName, 'r');
1136        if ($this->_fp) {
1137            if (file_exists($this->_fileName)) {
1138                $this->_type = 'file';
1139            }
1140            else {
1141                $this->_type = 'url';
1142            }
1143        } else {
1144            $this->_fp = null;
1145            return false;  // ERROR: Can't open file
1146        }
1147
1148        $this->_fpout = fopen($outputName, 'wb');
1149        if (!$this->_fpout) {
1150            $this->_fpout = null;
1151            fclose($this->_fp);
1152            $this->_fp = null;
1153            return false;  // ERROR: Can't open output file
1154        }
1155
1156        // Check for the JPEG signature
1157        $c1 = ord(fgetc($this->_fp));
1158        $c2 = ord(fgetc($this->_fp));
1159
1160        if ($c1 != 0xFF || $c2 != 0xD8) {   // (0xFF + SOI)
1161            return false;  // ERROR: File is not a JPEG
1162        }
1163
1164        fputs($this->_fpout, chr(0xFF), 1);
1165        fputs($this->_fpout, chr(0xD8), 1); // (0xFF + SOI)
1166
1167        $count = 0;
1168
1169        $done = false;
1170        $ok = true;
1171
1172        while (!$done) {
1173            // First, skip any non 0xFF bytes
1174            $discarded = 0;
1175            $c = ord(fgetc($this->_fp));
1176            while (!feof($this->_fp) && ($c != 0xFF)) {
1177                $discarded++;
1178                $c = ord(fgetc($this->_fp));
1179            }
1180            // Then skip all 0xFF until the marker byte
1181            do {
1182                $marker = ord(fgetc($this->_fp));
1183            } while (!feof($this->_fp) && ($marker == 0xFF));
1184
1185            if (feof($this->_fp)) {
1186                $ok = false;
1187                break; // ERROR: Unexpected EOF
1188            }
1189            if ($discarded != 0) {
1190                $ok = false;
1191                break; // ERROR: Extraneous data
1192            }
1193
1194            $length = ord(fgetc($this->_fp)) * 256 + ord(fgetc($this->_fp));
1195            if (feof($this->_fp)) {
1196                $ok = false;
1197                break; // ERROR: Unexpected EOF
1198            }
1199            if ($length < 2) {
1200                $ok = false;
1201                break; // ERROR: Extraneous data
1202            }
1203            $length = $length - 2; // The length we got counts itself
1204
1205            unset($data);
1206            if ($marker == 0xE1) { // APP1: EXIF data
1207                $data =& $this->_createMarkerEXIF();
1208                $wroteEXIF = true;
1209            }
1210            elseif ($marker == 0xED) { // APP13: IPTC / Photoshop data
1211                $data =& $this->_createMarkerAdobe();
1212                $wroteAdobe = true;
1213            }
1214            elseif ($marker == 0xDA) { // SOS: Start of scan... the image itself and the last block on the file
1215                $done = true;
1216            }
1217
1218            if (!$wroteEXIF && (($marker < 0xE0) || ($marker > 0xEF))) {
1219                if (isset($this->_info['exif']) && is_array($this->_info['exif'])) {
1220                    $exif =& $this->_createMarkerEXIF();
1221                    $this->_writeJPEGMarker(0xE1, strlen($exif), $exif, 0);
1222                    unset($exif);
1223                }
1224                $wroteEXIF = true;
1225            }
1226
1227            if (!$wroteAdobe && (($marker < 0xE0) || ($marker > 0xEF))) {
1228                if ((isset($this->_info['adobe']) && is_array($this->_info['adobe']))
1229                        || (isset($this->_info['iptc']) && is_array($this->_info['iptc']))) {
1230                    $adobe =& $this->_createMarkerAdobe();
1231                    $this->_writeJPEGMarker(0xED, strlen($adobe), $adobe, 0);
1232                    unset($adobe);
1233                }
1234                $wroteAdobe = true;
1235            }
1236
1237            $origLength = $length;
1238            if (isset($data)) {
1239                $length = strlen($data);
1240            }
1241
1242            if ($marker != -1) {
1243                $this->_writeJPEGMarker($marker, $length, $data, $origLength);
1244            }
1245        }
1246
1247        if ($this->_fp) {
1248            fclose($this->_fp);
1249            $this->_fp = null;
1250        }
1251
1252        if ($this->_fpout) {
1253            fclose($this->_fpout);
1254            $this->_fpout = null;
1255        }
1256
1257        return $ok;
1258    }
1259
1260    /*************************************************************/
1261
1262    /**
1263     * @param integer $marker
1264     * @param integer $length
1265     * @param string $data
1266     * @param integer $origLength
1267     *
1268     * @return bool
1269     */
1270    function _writeJPEGMarker($marker, $length, &$data, $origLength) {
1271        if ($length <= 0) {
1272            return false;
1273        }
1274
1275        fputs($this->_fpout, chr(0xFF), 1);
1276        fputs($this->_fpout, chr($marker), 1);
1277        fputs($this->_fpout, chr((($length + 2) & 0x0000FF00) >> 8), 1);
1278        fputs($this->_fpout, chr((($length + 2) & 0x000000FF) >> 0), 1);
1279
1280        if (isset($data)) {
1281            // Copy the generated data
1282            fputs($this->_fpout, $data, $length);
1283
1284            if ($origLength > 0) {   // Skip the original data
1285                $result = @fseek($this->_fp, $origLength, SEEK_CUR);
1286                // fseek doesn't seem to like HTTP 'files', but fgetc has no problem
1287                if ($result != 0) {
1288                    for ($i = 0; $i < $origLength; $i++) {
1289                        fgetc($this->_fp);
1290                    }
1291                }
1292            }
1293        } else {
1294            if ($marker == 0xDA) {  // Copy until EOF
1295                while (!feof($this->_fp)) {
1296                    $data = fread($this->_fp, 1024 * 16);
1297                    fputs($this->_fpout, $data, strlen($data));
1298                }
1299            } else { // Copy only $length bytes
1300                $data = @fread($this->_fp, $length);
1301                fputs($this->_fpout, $data, $length);
1302            }
1303        }
1304
1305        return true;
1306    }
1307
1308    /**
1309     * Gets basic info from the file - should work with non-JPEGs
1310     *
1311     * @author  Sebastian Delmont <sdelmont@zonageek.com>
1312     * @author  Andreas Gohr <andi@splitbrain.org>
1313     */
1314    function _parseFileInfo() {
1315        if (file_exists($this->_fileName) && is_file($this->_fileName)) {
1316            $this->_info['file'] = array();
1317            $this->_info['file']['Name'] = utf8_decodeFN(\dokuwiki\Utf8\PhpString::basename($this->_fileName));
1318            $this->_info['file']['Path'] = fullpath($this->_fileName);
1319            $this->_info['file']['Size'] = filesize($this->_fileName);
1320            if ($this->_info['file']['Size'] < 1024) {
1321                $this->_info['file']['NiceSize'] = $this->_info['file']['Size'] . 'B';
1322            } elseif ($this->_info['file']['Size'] < (1024 * 1024)) {
1323                $this->_info['file']['NiceSize'] = round($this->_info['file']['Size'] / 1024) . 'KB';
1324            } elseif ($this->_info['file']['Size'] < (1024 * 1024 * 1024)) {
1325                $this->_info['file']['NiceSize'] = round($this->_info['file']['Size'] / (1024*1024)) . 'MB';
1326            } else {
1327                $this->_info['file']['NiceSize'] = $this->_info['file']['Size'] . 'B';
1328            }
1329            $this->_info['file']['UnixTime'] = filemtime($this->_fileName);
1330
1331            // get image size directly from file
1332            if ($size = getimagesize($this->_fileName)) {
1333                $this->_info['file']['Width'] = $size[0];
1334                $this->_info['file']['Height'] = $size[1];
1335
1336                // set mime types and formats
1337                // http://php.net/manual/en/function.getimagesize.php
1338                // http://php.net/manual/en/function.image-type-to-mime-type.php
1339                switch ($size[2]) {
1340                    case 1:
1341                        $this->_info['file']['Mime'] = 'image/gif';
1342                        $this->_info['file']['Format'] = 'GIF';
1343                        break;
1344                    case 2:
1345                        $this->_info['file']['Mime'] = 'image/jpeg';
1346                        $this->_info['file']['Format'] = 'JPEG';
1347                        break;
1348                    case 3:
1349                        $this->_info['file']['Mime'] = 'image/png';
1350                        $this->_info['file']['Format'] = 'PNG';
1351                        break;
1352                    case 4:
1353                        $this->_info['file']['Mime'] = 'application/x-shockwave-flash';
1354                        $this->_info['file']['Format'] = 'SWF';
1355                        break;
1356                    case 5:
1357                        $this->_info['file']['Mime'] = 'image/psd';
1358                        $this->_info['file']['Format'] = 'PSD';
1359                        break;
1360                    case 6:
1361                        $this->_info['file']['Mime'] = 'image/bmp';
1362                        $this->_info['file']['Format'] = 'BMP';
1363                        break;
1364                    case 7:
1365                        $this->_info['file']['Mime'] = 'image/tiff';
1366                        $this->_info['file']['Format'] = 'TIFF (Intel)';
1367                        break;
1368                    case 8:
1369                        $this->_info['file']['Mime'] = 'image/tiff';
1370                        $this->_info['file']['Format'] = 'TIFF (Motorola)';
1371                        break;
1372                    case 9:
1373                        $this->_info['file']['Mime'] = 'application/octet-stream';
1374                        $this->_info['file']['Format'] = 'JPC';
1375                        break;
1376                    case 10:
1377                        $this->_info['file']['Mime'] = 'image/jp2';
1378                        $this->_info['file']['Format'] = 'JP2';
1379                        break;
1380                    case 11:
1381                        $this->_info['file']['Mime'] = 'application/octet-stream';
1382                        $this->_info['file']['Format'] = 'JPX';
1383                        break;
1384                    case 12:
1385                        $this->_info['file']['Mime'] = 'application/octet-stream';
1386                        $this->_info['file']['Format'] = 'JB2';
1387                        break;
1388                    case 13:
1389                        $this->_info['file']['Mime'] = 'application/x-shockwave-flash';
1390                        $this->_info['file']['Format'] = 'SWC';
1391                        break;
1392                    case 14:
1393                        $this->_info['file']['Mime'] = 'image/iff';
1394                        $this->_info['file']['Format'] = 'IFF';
1395                        break;
1396                    case 15:
1397                        $this->_info['file']['Mime'] = 'image/vnd.wap.wbmp';
1398                        $this->_info['file']['Format'] = 'WBMP';
1399                        break;
1400                    case 16:
1401                        $this->_info['file']['Mime'] = 'image/xbm';
1402                        $this->_info['file']['Format'] = 'XBM';
1403                        break;
1404                    default:
1405                        $this->_info['file']['Mime'] = 'image/unknown';
1406                }
1407            }
1408        } else {
1409            $this->_info['file'] = array();
1410            $this->_info['file']['Name'] = \dokuwiki\Utf8\PhpString::basename($this->_fileName);
1411            $this->_info['file']['Url'] = $this->_fileName;
1412        }
1413
1414        return true;
1415    }
1416
1417    /*************************************************************/
1418    function _parseMarkerJFIF() {
1419        if (!isset($this->_markers)) {
1420            $this->_readJPEG();
1421        }
1422
1423        if ($this->_markers == null || $this->_isMarkerDisabled(('jfif'))) {
1424            return false;
1425        }
1426
1427        try {
1428            $data = null;
1429            $count = count($this->_markers);
1430            for ($i = 0; $i < $count; $i++) {
1431                if ($this->_markers[$i]['marker'] == 0xE0) {
1432                    $signature = $this->_getFixedString($this->_markers[$i]['data'], 0, 4);
1433                    if ($signature == 'JFIF') {
1434                        $data =& $this->_markers[$i]['data'];
1435                        break;
1436                    }
1437                }
1438            }
1439
1440            if ($data == null) {
1441                $this->_info['jfif'] = false;
1442                return false;
1443            }
1444
1445            $this->_info['jfif'] = array();
1446
1447            $vmaj = $this->_getByte($data, 5);
1448            $vmin = $this->_getByte($data, 6);
1449
1450            $this->_info['jfif']['Version'] = sprintf('%d.%02d', $vmaj, $vmin);
1451
1452            $units = $this->_getByte($data, 7);
1453            switch ($units) {
1454                case 0:
1455                    $this->_info['jfif']['Units'] = 'pixels';
1456                    break;
1457                case 1:
1458                    $this->_info['jfif']['Units'] = 'dpi';
1459                    break;
1460                case 2:
1461                    $this->_info['jfif']['Units'] = 'dpcm';
1462                    break;
1463                default:
1464                    $this->_info['jfif']['Units'] = 'unknown';
1465                    break;
1466            }
1467
1468            $xdens = $this->_getShort($data, 8);
1469            $ydens = $this->_getShort($data, 10);
1470
1471            $this->_info['jfif']['XDensity'] = $xdens;
1472            $this->_info['jfif']['YDensity'] = $ydens;
1473
1474            $thumbx = $this->_getByte($data, 12);
1475            $thumby = $this->_getByte($data, 13);
1476
1477            $this->_info['jfif']['ThumbnailWidth'] = $thumbx;
1478            $this->_info['jfif']['ThumbnailHeight'] = $thumby;
1479        } catch(Exception $e) {
1480            $this->_handleMarkerParsingException($e);
1481            $this->_info['jfif'] = false;
1482            return false;
1483        }
1484
1485        return true;
1486    }
1487
1488    /*************************************************************/
1489    function _parseMarkerSOF() {
1490        if (!isset($this->_markers)) {
1491            $this->_readJPEG();
1492        }
1493
1494        if ($this->_markers == null || $this->_isMarkerDisabled(('sof'))) {
1495            return false;
1496        }
1497
1498        try {
1499            $data = null;
1500            $count = count($this->_markers);
1501            for ($i = 0; $i < $count; $i++) {
1502                switch ($this->_markers[$i]['marker']) {
1503                    case 0xC0: // SOF0
1504                    case 0xC1: // SOF1
1505                    case 0xC2: // SOF2
1506                    case 0xC9: // SOF9
1507                        $data =& $this->_markers[$i]['data'];
1508                        $marker = $this->_markers[$i]['marker'];
1509                        break;
1510                }
1511            }
1512
1513            if ($data == null) {
1514                $this->_info['sof'] = false;
1515                return false;
1516            }
1517
1518            $pos = 0;
1519            $this->_info['sof'] = array();
1520
1521            switch ($marker) {
1522                case 0xC0: // SOF0
1523                    $format = 'Baseline';
1524                    break;
1525                case 0xC1: // SOF1
1526                    $format = 'Progessive';
1527                    break;
1528                case 0xC2: // SOF2
1529                    $format = 'Non-baseline';
1530                    break;
1531                case 0xC9: // SOF9
1532                    $format = 'Arithmetic';
1533                    break;
1534                default:
1535                    return false;
1536            }
1537
1538            $this->_info['sof']['Format']          = $format;
1539            $this->_info['sof']['SamplePrecision'] = $this->_getByte($data, $pos + 0);
1540            $this->_info['sof']['ImageHeight']     = $this->_getShort($data, $pos + 1);
1541            $this->_info['sof']['ImageWidth']      = $this->_getShort($data, $pos + 3);
1542            $this->_info['sof']['ColorChannels']   = $this->_getByte($data, $pos + 5);
1543        } catch(Exception $e) {
1544            $this->_handleMarkerParsingException($e);
1545            $this->_info['sof'] = false;
1546            return false;
1547        }
1548
1549        return true;
1550    }
1551
1552    /**
1553     * Parses the XMP data
1554     *
1555     * @author  Hakan Sandell <hakan.sandell@mydata.se>
1556     */
1557    function _parseMarkerXmp() {
1558        if (!isset($this->_markers)) {
1559            $this->_readJPEG();
1560        }
1561
1562        if ($this->_markers == null || $this->_isMarkerDisabled(('xmp'))) {
1563            return false;
1564        }
1565
1566        try {
1567            $data = null;
1568            $count = count($this->_markers);
1569            for ($i = 0; $i < $count; $i++) {
1570                if ($this->_markers[$i]['marker'] == 0xE1) {
1571                    $signature = $this->_getFixedString($this->_markers[$i]['data'], 0, 29);
1572                    if ($signature == "http://ns.adobe.com/xap/1.0/\0") {
1573                        $data = substr($this->_markers[$i]['data'], 29);
1574                        break;
1575                    }
1576                }
1577            }
1578
1579            if ($data == null) {
1580                $this->_info['xmp'] = false;
1581                return false;
1582            }
1583
1584            $parser = xml_parser_create();
1585            xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
1586            xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1);
1587            $result = xml_parse_into_struct($parser, $data, $values, $tags);
1588            xml_parser_free($parser);
1589
1590            if ($result == 0) {
1591                $this->_info['xmp'] = false;
1592                return false;
1593            }
1594
1595            $this->_info['xmp'] = array();
1596            $count = count($values);
1597            for ($i = 0; $i < $count; $i++) {
1598                if ($values[$i]['tag'] == 'rdf:Description' && $values[$i]['type'] == 'open') {
1599
1600                    while ((++$i < $count) && ($values[$i]['tag'] != 'rdf:Description')) {
1601                        $this->_parseXmpNode($values, $i, $this->_info['xmp'][$values[$i]['tag']], $count);
1602                    }
1603                }
1604            }
1605        } catch (Exception $e) {
1606            $this->_handleMarkerParsingException($e);
1607            $this->_info['xmp'] = false;
1608            return false;
1609        }
1610
1611        return true;
1612    }
1613
1614    /**
1615     * Parses XMP nodes by recursion
1616     *
1617     * @author  Hakan Sandell <hakan.sandell@mydata.se>
1618     *
1619     * @param array $values
1620     * @param int $i
1621     * @param mixed $meta
1622     * @param integer $count
1623     */
1624    function _parseXmpNode($values, &$i, &$meta, $count) {
1625        if ($values[$i]['type'] == 'close') return;
1626
1627        if ($values[$i]['type'] == 'complete') {
1628            // Simple Type property
1629            $meta = $values[$i]['value'] ?? '';
1630            return;
1631        }
1632
1633        $i++;
1634        if ($i >= $count) return;
1635
1636        if ($values[$i]['tag'] == 'rdf:Bag' || $values[$i]['tag'] == 'rdf:Seq') {
1637            // Array property
1638            $meta = array();
1639            while ($values[++$i]['tag'] == 'rdf:li') {
1640                $this->_parseXmpNode($values, $i, $meta[], $count);
1641            }
1642            $i++; // skip closing Bag/Seq tag
1643
1644        } elseif ($values[$i]['tag'] == 'rdf:Alt') {
1645            // Language Alternative property, only the first (default) value is used
1646            if ($values[$i]['type'] == 'open') {
1647                $i++;
1648                $this->_parseXmpNode($values, $i, $meta, $count);
1649                while ((++$i < $count) && ($values[$i]['tag'] != 'rdf:Alt'));
1650                $i++; // skip closing Alt tag
1651            }
1652
1653        } else {
1654            // Structure property
1655            $meta = array();
1656            $startTag = $values[$i-1]['tag'];
1657            do {
1658                $this->_parseXmpNode($values, $i, $meta[$values[$i]['tag']], $count);
1659            } while ((++$i < $count) && ($values[$i]['tag'] != $startTag));
1660        }
1661    }
1662
1663    /*************************************************************/
1664    function _parseMarkerExif() {
1665        if (!isset($this->_markers)) {
1666            $this->_readJPEG();
1667        }
1668
1669        if ($this->_markers == null || $this->_isMarkerDisabled(('exif'))) {
1670            return false;
1671        }
1672
1673        try {
1674            $data = null;
1675            $count = count($this->_markers);
1676            for ($i = 0; $i < $count; $i++) {
1677                if ($this->_markers[$i]['marker'] == 0xE1) {
1678                    $signature = $this->_getFixedString($this->_markers[$i]['data'], 0, 6);
1679                    if ($signature == "Exif\0\0") {
1680                        $data =& $this->_markers[$i]['data'];
1681                        break;
1682                    }
1683                }
1684            }
1685
1686            if ($data == null) {
1687                $this->_info['exif'] = false;
1688                return false;
1689            }
1690            $pos = 6;
1691            $this->_info['exif'] = array();
1692
1693            // We don't increment $pos after this because Exif uses offsets relative to this point
1694
1695            $byteAlign = $this->_getShort($data, $pos + 0);
1696
1697            if ($byteAlign == 0x4949) { // "II"
1698                $isBigEndian = false;
1699            } elseif ($byteAlign == 0x4D4D) { // "MM"
1700                $isBigEndian = true;
1701            } else {
1702                return false; // Unexpected data
1703            }
1704
1705            $alignCheck = $this->_getShort($data, $pos + 2, $isBigEndian);
1706            if ($alignCheck != 0x002A) // That's the expected value
1707                return false; // Unexpected data
1708
1709            if ($isBigEndian) {
1710                $this->_info['exif']['ByteAlign'] = "Big Endian";
1711            } else {
1712                $this->_info['exif']['ByteAlign'] = "Little Endian";
1713            }
1714
1715            $offsetIFD0 = $this->_getLong($data, $pos + 4, $isBigEndian);
1716            if ($offsetIFD0 < 8)
1717                return false; // Unexpected data
1718
1719            $offsetIFD1 = $this->_readIFD($data, $pos, $offsetIFD0, $isBigEndian, 'ifd0');
1720            if ($offsetIFD1 != 0)
1721                $this->_readIFD($data, $pos, $offsetIFD1, $isBigEndian, 'ifd1');
1722        } catch(Exception $e) {
1723            $this->_handleMarkerParsingException($e);
1724            $this->_info['exif'] = false;
1725            return false;
1726        }
1727
1728        return true;
1729    }
1730
1731    /*************************************************************/
1732
1733    /**
1734     * @param mixed $data
1735     * @param integer $base
1736     * @param integer $offset
1737     * @param boolean $isBigEndian
1738     * @param string $mode
1739     *
1740     * @return int
1741     */
1742    function _readIFD($data, $base, $offset, $isBigEndian, $mode) {
1743        $EXIFTags = $this->_exifTagNames($mode);
1744
1745        $numEntries = $this->_getShort($data, $base + $offset, $isBigEndian);
1746        $offset += 2;
1747
1748        $exifTIFFOffset = 0;
1749        $exifTIFFLength = 0;
1750        $exifThumbnailOffset = 0;
1751        $exifThumbnailLength = 0;
1752
1753        for ($i = 0; $i < $numEntries; $i++) {
1754            $tag = $this->_getShort($data, $base + $offset, $isBigEndian);
1755            $offset += 2;
1756            $type = $this->_getShort($data, $base + $offset, $isBigEndian);
1757            $offset += 2;
1758            $count = $this->_getLong($data, $base + $offset, $isBigEndian);
1759            $offset += 4;
1760
1761            if (($type < 1) || ($type > 12))
1762                return false; // Unexpected Type
1763
1764            $typeLengths = array( -1, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8 );
1765
1766            $dataLength = $typeLengths[$type] * $count;
1767            if ($dataLength > 4) {
1768                $dataOffset = $this->_getLong($data, $base + $offset, $isBigEndian);
1769                $rawValue = $this->_getFixedString($data, $base + $dataOffset, $dataLength);
1770            } else {
1771                $rawValue = $this->_getFixedString($data, $base + $offset, $dataLength);
1772            }
1773            $offset += 4;
1774
1775            switch ($type) {
1776                case 1:    // UBYTE
1777                    if ($count == 1) {
1778                        $value = $this->_getByte($rawValue, 0);
1779                    } else {
1780                        $value = array();
1781                        for ($j = 0; $j < $count; $j++)
1782                            $value[$j] = $this->_getByte($rawValue, $j);
1783                    }
1784                    break;
1785                case 2:    // ASCII
1786                    $value = $rawValue;
1787                    break;
1788                case 3:    // USHORT
1789                    if ($count == 1) {
1790                        $value = $this->_getShort($rawValue, 0, $isBigEndian);
1791                    } else {
1792                        $value = array();
1793                        for ($j = 0; $j < $count; $j++)
1794                            $value[$j] = $this->_getShort($rawValue, $j * 2, $isBigEndian);
1795                    }
1796                    break;
1797                case 4:    // ULONG
1798                    if ($count == 1) {
1799                        $value = $this->_getLong($rawValue, 0, $isBigEndian);
1800                    } else {
1801                        $value = array();
1802                        for ($j = 0; $j < $count; $j++)
1803                            $value[$j] = $this->_getLong($rawValue, $j * 4, $isBigEndian);
1804                    }
1805                    break;
1806                case 5:    // URATIONAL
1807                    if ($count == 1) {
1808                        $a = $this->_getLong($rawValue, 0, $isBigEndian);
1809                        $b = $this->_getLong($rawValue, 4, $isBigEndian);
1810                        $value = array();
1811                        $value['val'] = 0;
1812                        $value['num'] = $a;
1813                        $value['den'] = $b;
1814                        if (($a != 0) && ($b != 0)) {
1815                            $value['val'] = $a / $b;
1816                        }
1817                    } else {
1818                        $value = array();
1819                        for ($j = 0; $j < $count; $j++) {
1820                            $a = $this->_getLong($rawValue, $j * 8, $isBigEndian);
1821                            $b = $this->_getLong($rawValue, ($j * 8) + 4, $isBigEndian);
1822                            $value = array();
1823                            $value[$j]['val'] = 0;
1824                            $value[$j]['num'] = $a;
1825                            $value[$j]['den'] = $b;
1826                            if (($a != 0) && ($b != 0))
1827                                $value[$j]['val'] = $a / $b;
1828                        }
1829                    }
1830                    break;
1831                case 6:    // SBYTE
1832                    if ($count == 1) {
1833                        $value = $this->_getByte($rawValue, 0);
1834                    } else {
1835                        $value = array();
1836                        for ($j = 0; $j < $count; $j++)
1837                            $value[$j] = $this->_getByte($rawValue, $j);
1838                    }
1839                    break;
1840                case 7:    // UNDEFINED
1841                    $value = $rawValue;
1842                    break;
1843                case 8:    // SSHORT
1844                    if ($count == 1) {
1845                        $value = $this->_getShort($rawValue, 0, $isBigEndian);
1846                    } else {
1847                        $value = array();
1848                        for ($j = 0; $j < $count; $j++)
1849                            $value[$j] = $this->_getShort($rawValue, $j * 2, $isBigEndian);
1850                    }
1851                    break;
1852                case 9:    // SLONG
1853                    if ($count == 1) {
1854                        $value = $this->_getLong($rawValue, 0, $isBigEndian);
1855                    } else {
1856                        $value = array();
1857                        for ($j = 0; $j < $count; $j++)
1858                            $value[$j] = $this->_getLong($rawValue, $j * 4, $isBigEndian);
1859                    }
1860                    break;
1861                case 10:   // SRATIONAL
1862                    if ($count == 1) {
1863                        $a = $this->_getLong($rawValue, 0, $isBigEndian);
1864                        $b = $this->_getLong($rawValue, 4, $isBigEndian);
1865                        $value = array();
1866                        $value['val'] = 0;
1867                        $value['num'] = $a;
1868                        $value['den'] = $b;
1869                        if (($a != 0) && ($b != 0))
1870                            $value['val'] = $a / $b;
1871                    } else {
1872                        $value = array();
1873                        for ($j = 0; $j < $count; $j++) {
1874                            $a = $this->_getLong($rawValue, $j * 8, $isBigEndian);
1875                            $b = $this->_getLong($rawValue, ($j * 8) + 4, $isBigEndian);
1876                            $value = array();
1877                            $value[$j]['val'] = 0;
1878                            $value[$j]['num'] = $a;
1879                            $value[$j]['den'] = $b;
1880                            if (($a != 0) && ($b != 0))
1881                                $value[$j]['val'] = $a / $b;
1882                        }
1883                    }
1884                    break;
1885                case 11:   // FLOAT
1886                    $value = $rawValue;
1887                    break;
1888
1889                case 12:   // DFLOAT
1890                    $value = $rawValue;
1891                    break;
1892                default:
1893                    return false; // Unexpected Type
1894            }
1895
1896            $tagName = '';
1897            if (($mode == 'ifd0') && ($tag == 0x8769)) {  // ExifIFDOffset
1898                $this->_readIFD($data, $base, $value, $isBigEndian, 'exif');
1899            } elseif (($mode == 'ifd0') && ($tag == 0x8825)) {  // GPSIFDOffset
1900                $this->_readIFD($data, $base, $value, $isBigEndian, 'gps');
1901            } elseif (($mode == 'ifd1') && ($tag == 0x0111)) {  // TIFFStripOffsets
1902                $exifTIFFOffset = $value;
1903            } elseif (($mode == 'ifd1') && ($tag == 0x0117)) {  // TIFFStripByteCounts
1904                $exifTIFFLength = $value;
1905            } elseif (($mode == 'ifd1') && ($tag == 0x0201)) {  // TIFFJFIFOffset
1906                $exifThumbnailOffset = $value;
1907            } elseif (($mode == 'ifd1') && ($tag == 0x0202)) {  // TIFFJFIFLength
1908                $exifThumbnailLength = $value;
1909            } elseif (($mode == 'exif') && ($tag == 0xA005)) {  // InteropIFDOffset
1910                $this->_readIFD($data, $base, $value, $isBigEndian, 'interop');
1911            }
1912            // elseif (($mode == 'exif') && ($tag == 0x927C)) {  // MakerNote
1913            // }
1914            else {
1915                if (isset($EXIFTags[$tag])) {
1916                    $tagName = $EXIFTags[$tag];
1917                    if (isset($this->_info['exif'][$tagName])) {
1918                        if (!is_array($this->_info['exif'][$tagName])) {
1919                            $aux = array();
1920                            $aux[0] = $this->_info['exif'][$tagName];
1921                            $this->_info['exif'][$tagName] = $aux;
1922                        }
1923
1924                        $this->_info['exif'][$tagName][count($this->_info['exif'][$tagName])] = $value;
1925                    } else {
1926                        $this->_info['exif'][$tagName] = $value;
1927                    }
1928                }
1929                /*
1930                 else {
1931                    echo sprintf("<h1>Unknown tag %02x (t: %d l: %d) %s in %s</h1>", $tag, $type, $count, $mode, $this->_fileName);
1932                    // Unknown Tags will be ignored!!!
1933                    // That's because the tag might be a pointer (like the Exif tag)
1934                    // and saving it without saving the data it points to might
1935                    // create an invalid file.
1936                }
1937                */
1938            }
1939        }
1940
1941        if (($exifThumbnailOffset > 0) && ($exifThumbnailLength > 0)) {
1942            $this->_info['exif']['JFIFThumbnail'] = $this->_getFixedString($data, $base + $exifThumbnailOffset, $exifThumbnailLength);
1943        }
1944
1945        if (($exifTIFFOffset > 0) && ($exifTIFFLength > 0)) {
1946            $this->_info['exif']['TIFFStrips'] = $this->_getFixedString($data, $base + $exifTIFFOffset, $exifTIFFLength);
1947        }
1948
1949        $nextOffset = $this->_getLong($data, $base + $offset, $isBigEndian);
1950        return $nextOffset;
1951    }
1952
1953    /*************************************************************/
1954    function & _createMarkerExif() {
1955        $data = null;
1956        $count = count($this->_markers);
1957        for ($i = 0; $i < $count; $i++) {
1958            if ($this->_markers[$i]['marker'] == 0xE1) {
1959                $signature = $this->_getFixedString($this->_markers[$i]['data'], 0, 6);
1960                if ($signature == "Exif\0\0") {
1961                    $data =& $this->_markers[$i]['data'];
1962                    break;
1963                }
1964            }
1965        }
1966
1967        if (!isset($this->_info['exif'])) {
1968            return false;
1969        }
1970
1971        $data = "Exif\0\0";
1972        $pos = 6;
1973        $offsetBase = 6;
1974
1975        if (isset($this->_info['exif']['ByteAlign']) && ($this->_info['exif']['ByteAlign'] == "Big Endian")) {
1976            $isBigEndian = true;
1977            $aux = "MM";
1978            $pos = $this->_putString($data, $pos, $aux);
1979        } else {
1980            $isBigEndian = false;
1981            $aux = "II";
1982            $pos = $this->_putString($data, $pos, $aux);
1983        }
1984        $pos = $this->_putShort($data, $pos, 0x002A, $isBigEndian);
1985        $pos = $this->_putLong($data, $pos, 0x00000008, $isBigEndian); // IFD0 Offset is always 8
1986
1987        $ifd0 =& $this->_getIFDEntries($isBigEndian, 'ifd0');
1988        $ifd1 =& $this->_getIFDEntries($isBigEndian, 'ifd1');
1989
1990        $pos = $this->_writeIFD($data, $pos, $offsetBase, $ifd0, $isBigEndian, true);
1991        $pos = $this->_writeIFD($data, $pos, $offsetBase, $ifd1, $isBigEndian, false);
1992
1993        return $data;
1994    }
1995
1996    /*************************************************************/
1997
1998    /**
1999     * @param mixed $data
2000     * @param integer $pos
2001     * @param integer $offsetBase
2002     * @param array $entries
2003     * @param boolean $isBigEndian
2004     * @param boolean $hasNext
2005     *
2006     * @return mixed
2007     */
2008    function _writeIFD(&$data, $pos, $offsetBase, &$entries, $isBigEndian, $hasNext) {
2009        $tiffData = null;
2010        $tiffDataOffsetPos = -1;
2011
2012        $entryCount = count($entries);
2013
2014        $dataPos = $pos + 2 + ($entryCount * 12) + 4;
2015        $pos = $this->_putShort($data, $pos, $entryCount, $isBigEndian);
2016
2017        for ($i = 0; $i < $entryCount; $i++) {
2018            $tag = $entries[$i]['tag'];
2019            $type = $entries[$i]['type'];
2020
2021            if ($type == -99) { // SubIFD
2022                $pos = $this->_putShort($data, $pos, $tag, $isBigEndian);
2023                $pos = $this->_putShort($data, $pos, 0x04, $isBigEndian); // LONG
2024                $pos = $this->_putLong($data, $pos, 0x01, $isBigEndian); // Count = 1
2025                $pos = $this->_putLong($data, $pos, $dataPos - $offsetBase, $isBigEndian);
2026
2027                $dataPos = $this->_writeIFD($data, $dataPos, $offsetBase, $entries[$i]['value'], $isBigEndian, false);
2028            } elseif ($type == -98) { // TIFF Data
2029                $pos = $this->_putShort($data, $pos, $tag, $isBigEndian);
2030                $pos = $this->_putShort($data, $pos, 0x04, $isBigEndian); // LONG
2031                $pos = $this->_putLong($data, $pos, 0x01, $isBigEndian); // Count = 1
2032                $tiffDataOffsetPos = $pos;
2033                $pos = $this->_putLong($data, $pos, 0x00, $isBigEndian); // For Now
2034                $tiffData =& $entries[$i]['value'] ;
2035            } else { // Regular Entry
2036                $pos = $this->_putShort($data, $pos, $tag, $isBigEndian);
2037                $pos = $this->_putShort($data, $pos, $type, $isBigEndian);
2038                $pos = $this->_putLong($data, $pos, $entries[$i]['count'], $isBigEndian);
2039                if (strlen($entries[$i]['value']) > 4) {
2040                    $pos = $this->_putLong($data, $pos, $dataPos - $offsetBase, $isBigEndian);
2041                    $dataPos = $this->_putString($data, $dataPos, $entries[$i]['value']);
2042                } else {
2043                    $val = str_pad($entries[$i]['value'], 4, "\0");
2044                    $pos = $this->_putString($data, $pos, $val);
2045                }
2046            }
2047        }
2048
2049        if ($tiffData != null) {
2050            $this->_putLong($data, $tiffDataOffsetPos, $dataPos - $offsetBase, $isBigEndian);
2051            $dataPos = $this->_putString($data, $dataPos, $tiffData);
2052        }
2053
2054        if ($hasNext) {
2055            $pos = $this->_putLong($data, $pos, $dataPos - $offsetBase, $isBigEndian);
2056        } else {
2057            $pos = $this->_putLong($data, $pos, 0, $isBigEndian);
2058        }
2059
2060        return $dataPos;
2061    }
2062
2063    /*************************************************************/
2064
2065    /**
2066     * @param boolean $isBigEndian
2067     * @param string $mode
2068     *
2069     * @return array
2070     */
2071    function & _getIFDEntries($isBigEndian, $mode) {
2072        $EXIFNames = $this->_exifTagNames($mode);
2073        $EXIFTags = $this->_exifNameTags($mode);
2074        $EXIFTypeInfo = $this->_exifTagTypes($mode);
2075
2076        $ifdEntries = array();
2077        $entryCount = 0;
2078
2079        foreach($EXIFNames as $tag => $name) {
2080            $type = $EXIFTypeInfo[$tag][0];
2081            $count = $EXIFTypeInfo[$tag][1];
2082            $value = null;
2083
2084            if (($mode == 'ifd0') && ($tag == 0x8769)) {  // ExifIFDOffset
2085                if (isset($this->_info['exif']['EXIFVersion'])) {
2086                    $value =& $this->_getIFDEntries($isBigEndian, "exif");
2087                    $type = -99;
2088                }
2089                else {
2090                    $value = null;
2091                }
2092            } elseif (($mode == 'ifd0') && ($tag == 0x8825)) {  // GPSIFDOffset
2093                if (isset($this->_info['exif']['GPSVersionID'])) {
2094                    $value =& $this->_getIFDEntries($isBigEndian, "gps");
2095                    $type = -99;
2096                } else {
2097                    $value = null;
2098                }
2099            } elseif (($mode == 'ifd1') && ($tag == 0x0111)) {  // TIFFStripOffsets
2100                if (isset($this->_info['exif']['TIFFStrips'])) {
2101                    $value =& $this->_info['exif']['TIFFStrips'];
2102                    $type = -98;
2103                } else {
2104                    $value = null;
2105                }
2106            } elseif (($mode == 'ifd1') && ($tag == 0x0117)) {  // TIFFStripByteCounts
2107                if (isset($this->_info['exif']['TIFFStrips'])) {
2108                    $value = strlen($this->_info['exif']['TIFFStrips']);
2109                } else {
2110                    $value = null;
2111                }
2112            } elseif (($mode == 'ifd1') && ($tag == 0x0201)) {  // TIFFJFIFOffset
2113                if (isset($this->_info['exif']['JFIFThumbnail'])) {
2114                    $value =& $this->_info['exif']['JFIFThumbnail'];
2115                    $type = -98;
2116                } else {
2117                    $value = null;
2118                }
2119            } elseif (($mode == 'ifd1') && ($tag == 0x0202)) {  // TIFFJFIFLength
2120                if (isset($this->_info['exif']['JFIFThumbnail'])) {
2121                    $value = strlen($this->_info['exif']['JFIFThumbnail']);
2122                } else {
2123                    $value = null;
2124                }
2125            } elseif (($mode == 'exif') && ($tag == 0xA005)) {  // InteropIFDOffset
2126                if (isset($this->_info['exif']['InteroperabilityIndex'])) {
2127                    $value =& $this->_getIFDEntries($isBigEndian, "interop");
2128                    $type = -99;
2129                } else {
2130                    $value = null;
2131                }
2132            } elseif (isset($this->_info['exif'][$name])) {
2133                $origValue =& $this->_info['exif'][$name];
2134
2135                // This makes it easier to process variable size elements
2136                if (!is_array($origValue) || isset($origValue['val'])) {
2137                    unset($origValue); // Break the reference
2138                    $origValue = array($this->_info['exif'][$name]);
2139                }
2140                $origCount = count($origValue);
2141
2142                if ($origCount == 0 ) {
2143                    $type = -1;  // To ignore this field
2144                }
2145
2146                $value = " ";
2147
2148                switch ($type) {
2149                    case 1:    // UBYTE
2150                        if ($count == 0) {
2151                            $count = $origCount;
2152                        }
2153
2154                        $j = 0;
2155                        while (($j < $count) && ($j < $origCount)) {
2156
2157                            $this->_putByte($value, $j, $origValue[$j]);
2158                            $j++;
2159                        }
2160
2161                        while ($j < $count) {
2162                            $this->_putByte($value, $j, 0);
2163                            $j++;
2164                        }
2165                        break;
2166                    case 2:    // ASCII
2167                        $v = strval($origValue[0]);
2168                        if (($count != 0) && (strlen($v) > $count)) {
2169                            $v = substr($v, 0, $count);
2170                        }
2171                        elseif (($count > 0) && (strlen($v) < $count)) {
2172                            $v = str_pad($v, $count, "\0");
2173                        }
2174
2175                        $count = strlen($v);
2176
2177                        $this->_putString($value, 0, $v);
2178                        break;
2179                    case 3:    // USHORT
2180                        if ($count == 0) {
2181                            $count = $origCount;
2182                        }
2183
2184                        $j = 0;
2185                        while (($j < $count) && ($j < $origCount)) {
2186                            $this->_putShort($value, $j * 2, $origValue[$j], $isBigEndian);
2187                            $j++;
2188                        }
2189
2190                        while ($j < $count) {
2191                            $this->_putShort($value, $j * 2, 0, $isBigEndian);
2192                            $j++;
2193                        }
2194                        break;
2195                    case 4:    // ULONG
2196                        if ($count == 0) {
2197                            $count = $origCount;
2198                        }
2199
2200                        $j = 0;
2201                        while (($j < $count) && ($j < $origCount)) {
2202                            $this->_putLong($value, $j * 4, $origValue[$j], $isBigEndian);
2203                            $j++;
2204                        }
2205
2206                        while ($j < $count) {
2207                            $this->_putLong($value, $j * 4, 0, $isBigEndian);
2208                            $j++;
2209                        }
2210                        break;
2211                    case 5:    // URATIONAL
2212                        if ($count == 0) {
2213                            $count = $origCount;
2214                        }
2215
2216                        $j = 0;
2217                        while (($j < $count) && ($j < $origCount)) {
2218                            $v = $origValue[$j];
2219                            if (is_array($v)) {
2220                                $a = $v['num'];
2221                                $b = $v['den'];
2222                            }
2223                            else {
2224                                $a = 0;
2225                                $b = 0;
2226                                // TODO: Allow other types and convert them
2227                            }
2228                            $this->_putLong($value, $j * 8, $a, $isBigEndian);
2229                            $this->_putLong($value, ($j * 8) + 4, $b, $isBigEndian);
2230                            $j++;
2231                        }
2232
2233                        while ($j < $count) {
2234                            $this->_putLong($value, $j * 8, 0, $isBigEndian);
2235                            $this->_putLong($value, ($j * 8) + 4, 0, $isBigEndian);
2236                            $j++;
2237                        }
2238                        break;
2239                    case 6:    // SBYTE
2240                        if ($count == 0) {
2241                            $count = $origCount;
2242                        }
2243
2244                        $j = 0;
2245                        while (($j < $count) && ($j < $origCount)) {
2246                            $this->_putByte($value, $j, $origValue[$j]);
2247                            $j++;
2248                        }
2249
2250                        while ($j < $count) {
2251                            $this->_putByte($value, $j, 0);
2252                            $j++;
2253                        }
2254                        break;
2255                    case 7:    // UNDEFINED
2256                        $v = strval($origValue[0]);
2257                        if (($count != 0) && (strlen($v) > $count)) {
2258                            $v = substr($v, 0, $count);
2259                        }
2260                        elseif (($count > 0) && (strlen($v) < $count)) {
2261                            $v = str_pad($v, $count, "\0");
2262                        }
2263
2264                        $count = strlen($v);
2265
2266                        $this->_putString($value, 0, $v);
2267                        break;
2268                    case 8:    // SSHORT
2269                        if ($count == 0) {
2270                            $count = $origCount;
2271                        }
2272
2273                        $j = 0;
2274                        while (($j < $count) && ($j < $origCount)) {
2275                            $this->_putShort($value, $j * 2, $origValue[$j], $isBigEndian);
2276                            $j++;
2277                        }
2278
2279                        while ($j < $count) {
2280                            $this->_putShort($value, $j * 2, 0, $isBigEndian);
2281                            $j++;
2282                        }
2283                        break;
2284                    case 9:    // SLONG
2285                        if ($count == 0) {
2286                            $count = $origCount;
2287                        }
2288
2289                        $j = 0;
2290                        while (($j < $count) && ($j < $origCount)) {
2291                            $this->_putLong($value, $j * 4, $origValue[$j], $isBigEndian);
2292                            $j++;
2293                        }
2294
2295                        while ($j < $count) {
2296                            $this->_putLong($value, $j * 4, 0, $isBigEndian);
2297                            $j++;
2298                        }
2299                        break;
2300                    case 10:   // SRATIONAL
2301                        if ($count == 0) {
2302                            $count = $origCount;
2303                        }
2304
2305                        $j = 0;
2306                        while (($j < $count) && ($j < $origCount)) {
2307                            $v = $origValue[$j];
2308                            if (is_array($v)) {
2309                                $a = $v['num'];
2310                                $b = $v['den'];
2311                            }
2312                            else {
2313                                $a = 0;
2314                                $b = 0;
2315                                // TODO: Allow other types and convert them
2316                            }
2317
2318                            $this->_putLong($value, $j * 8, $a, $isBigEndian);
2319                            $this->_putLong($value, ($j * 8) + 4, $b, $isBigEndian);
2320                            $j++;
2321                        }
2322
2323                        while ($j < $count) {
2324                            $this->_putLong($value, $j * 8, 0, $isBigEndian);
2325                            $this->_putLong($value, ($j * 8) + 4, 0, $isBigEndian);
2326                            $j++;
2327                        }
2328                        break;
2329                    case 11:   // FLOAT
2330                        if ($count == 0) {
2331                            $count = $origCount;
2332                        }
2333
2334                        $j = 0;
2335                        while (($j < $count) && ($j < $origCount)) {
2336                            $v = strval($origValue[$j]);
2337                            if (strlen($v) > 4) {
2338                                $v = substr($v, 0, 4);
2339                            }
2340                            elseif (strlen($v) < 4) {
2341                                $v = str_pad($v, 4, "\0");
2342                            }
2343                            $this->_putString($value, $j * 4, $v);
2344                            $j++;
2345                        }
2346
2347                        while ($j < $count) {
2348                            $v = "\0\0\0\0";
2349                            $this->_putString($value, $j * 4, $v);
2350                            $j++;
2351                        }
2352                        break;
2353                    case 12:   // DFLOAT
2354                        if ($count == 0) {
2355                            $count = $origCount;
2356                        }
2357
2358                        $j = 0;
2359                        while (($j < $count) && ($j < $origCount)) {
2360                            $v = strval($origValue[$j]);
2361                            if (strlen($v) > 8) {
2362                                $v = substr($v, 0, 8);
2363                            }
2364                            elseif (strlen($v) < 8) {
2365                                $v = str_pad($v, 8, "\0");
2366                            }
2367                            $this->_putString($value, $j * 8, $v);
2368                            $j++;
2369                        }
2370
2371                        while ($j < $count) {
2372                            $v = "\0\0\0\0\0\0\0\0";
2373                            $this->_putString($value, $j * 8, $v);
2374                            $j++;
2375                        }
2376                        break;
2377                    default:
2378                        $value = null;
2379                        break;
2380                }
2381            }
2382
2383            if ($value != null) {
2384                $ifdEntries[$entryCount] = array();
2385                $ifdEntries[$entryCount]['tag'] = $tag;
2386                $ifdEntries[$entryCount]['type'] = $type;
2387                $ifdEntries[$entryCount]['count'] = $count;
2388                $ifdEntries[$entryCount]['value'] = $value;
2389
2390                $entryCount++;
2391            }
2392        }
2393
2394        return $ifdEntries;
2395    }
2396    /*************************************************************/
2397    function _handleMarkerParsingException($e) {
2398        \dokuwiki\ErrorHandler::logException($e, $this->_fileName);
2399    }
2400
2401    /*************************************************************/
2402    function _isMarkerDisabled($name) {
2403        if (!isset($this->_info)) return false;
2404        return isset($this->_info[$name]) && $this->_info[$name] === false;
2405    }
2406
2407    /*************************************************************/
2408    function _parseMarkerAdobe() {
2409        if (!isset($this->_markers)) {
2410            $this->_readJPEG();
2411        }
2412
2413        if ($this->_markers == null || $this->_isMarkerDisabled('adobe')) {
2414            return false;
2415        }
2416        try {
2417            $data = null;
2418            $count = count($this->_markers);
2419            for ($i = 0; $i < $count; $i++) {
2420                if ($this->_markers[$i]['marker'] == 0xED) {
2421                    $signature = $this->_getFixedString($this->_markers[$i]['data'], 0, 14);
2422                    if ($signature == "Photoshop 3.0\0") {
2423                        $data =& $this->_markers[$i]['data'];
2424                        break;
2425                    }
2426                }
2427            }
2428
2429            if ($data == null) {
2430                $this->_info['adobe'] = false;
2431                $this->_info['iptc'] = false;
2432                return false;
2433            }
2434            $pos = 14;
2435            $this->_info['adobe'] = array();
2436            $this->_info['adobe']['raw'] = array();
2437            $this->_info['iptc'] = array();
2438
2439            $datasize = strlen($data);
2440
2441            while ($pos < $datasize) {
2442                $signature = $this->_getFixedString($data, $pos, 4);
2443                if ($signature != '8BIM')
2444                    return false;
2445                $pos += 4;
2446
2447                $type = $this->_getShort($data, $pos);
2448                $pos += 2;
2449
2450                $strlen = $this->_getByte($data, $pos);
2451                $pos += 1;
2452                $header = '';
2453                for ($i = 0; $i < $strlen; $i++) {
2454                    $header .= $data[$pos + $i];
2455                }
2456                $pos += $strlen + 1 - ($strlen % 2);  // The string is padded to even length, counting the length byte itself
2457
2458                $length = $this->_getLong($data, $pos);
2459                $pos += 4;
2460
2461                $basePos = $pos;
2462
2463                switch ($type) {
2464                    case 0x0404: // Caption (IPTC Data)
2465                        $pos = $this->_readIPTC($data, $pos);
2466                        if ($pos == false)
2467                            return false;
2468                        break;
2469                    case 0x040A: // CopyrightFlag
2470                        $this->_info['adobe']['CopyrightFlag'] = $this->_getByte($data, $pos);
2471                        $pos += $length;
2472                        break;
2473                    case 0x040B: // ImageURL
2474                        $this->_info['adobe']['ImageURL'] = $this->_getFixedString($data, $pos, $length);
2475                        $pos += $length;
2476                        break;
2477                    case 0x040C: // Thumbnail
2478                        $aux = $this->_getLong($data, $pos);
2479                        $pos += 4;
2480                        if ($aux == 1) {
2481                            $this->_info['adobe']['ThumbnailWidth'] = $this->_getLong($data, $pos);
2482                            $pos += 4;
2483                            $this->_info['adobe']['ThumbnailHeight'] = $this->_getLong($data, $pos);
2484                            $pos += 4;
2485
2486                            $pos += 16; // Skip some data
2487
2488                            $this->_info['adobe']['ThumbnailData'] = $this->_getFixedString($data, $pos, $length - 28);
2489                            $pos += $length - 28;
2490                        }
2491                        break;
2492                    default:
2493                        break;
2494                }
2495
2496                // We save all blocks, even those we recognized
2497                $label = sprintf('8BIM_0x%04x', $type);
2498                $this->_info['adobe']['raw'][$label] = array();
2499                $this->_info['adobe']['raw'][$label]['type'] = $type;
2500                $this->_info['adobe']['raw'][$label]['header'] = $header;
2501                $this->_info['adobe']['raw'][$label]['data'] =& $this->_getFixedString($data, $basePos, $length);
2502
2503                $pos = $basePos + $length + ($length % 2); // Even padding
2504            }
2505        } catch(Exception $e) {
2506            $this->_handleMarkerParsingException($e);
2507            $this->_info['adobe'] = false;
2508            $this->_info['iptc'] = false;
2509            return false;
2510        }
2511    }
2512
2513    /*************************************************************/
2514    function _readIPTC(&$data, $pos = 0) {
2515        $totalLength = strlen($data);
2516
2517        $IPTCTags = $this->_iptcTagNames();
2518
2519        while ($pos < ($totalLength - 5)) {
2520            $signature = $this->_getShort($data, $pos);
2521            if ($signature != 0x1C02)
2522                return $pos;
2523            $pos += 2;
2524
2525            $type = $this->_getByte($data, $pos);
2526            $pos += 1;
2527            $length = $this->_getShort($data, $pos);
2528            $pos += 2;
2529
2530            $basePos = $pos;
2531            $label = '';
2532
2533            if (isset($IPTCTags[$type])) {
2534                $label = $IPTCTags[$type];
2535            } else {
2536                $label = sprintf('IPTC_0x%02x', $type);
2537            }
2538
2539            if ($label != '') {
2540                if (isset($this->_info['iptc'][$label])) {
2541                    if (!is_array($this->_info['iptc'][$label])) {
2542                        $aux = array();
2543                        $aux[0] = $this->_info['iptc'][$label];
2544                        $this->_info['iptc'][$label] = $aux;
2545                    }
2546                    $this->_info['iptc'][$label][ count($this->_info['iptc'][$label]) ] = $this->_getFixedString($data, $pos, $length);
2547                } else {
2548                    $this->_info['iptc'][$label] = $this->_getFixedString($data, $pos, $length);
2549                }
2550            }
2551
2552            $pos = $basePos + $length; // No padding
2553        }
2554        return $pos;
2555    }
2556
2557    /*************************************************************/
2558    function & _createMarkerAdobe() {
2559        if (isset($this->_info['iptc'])) {
2560            if (!isset($this->_info['adobe'])) {
2561                $this->_info['adobe'] = array();
2562            }
2563            if (!isset($this->_info['adobe']['raw'])) {
2564                $this->_info['adobe']['raw'] = array();
2565            }
2566            if (!isset($this->_info['adobe']['raw']['8BIM_0x0404'])) {
2567                $this->_info['adobe']['raw']['8BIM_0x0404'] = array();
2568            }
2569            $this->_info['adobe']['raw']['8BIM_0x0404']['type'] = 0x0404;
2570            $this->_info['adobe']['raw']['8BIM_0x0404']['header'] = "Caption";
2571            $this->_info['adobe']['raw']['8BIM_0x0404']['data'] =& $this->_writeIPTC();
2572        }
2573
2574        if (isset($this->_info['adobe']['raw']) && (count($this->_info['adobe']['raw']) > 0)) {
2575            $data = "Photoshop 3.0\0";
2576            $pos = 14;
2577
2578            reset($this->_info['adobe']['raw']);
2579            foreach ($this->_info['adobe']['raw'] as $value){
2580                $pos = $this->_write8BIM(
2581                        $data,
2582                        $pos,
2583                        $value['type'],
2584                        $value['header'],
2585                        $value['data'] );
2586            }
2587        }
2588
2589        return $data;
2590    }
2591
2592    /*************************************************************/
2593
2594    /**
2595     * @param mixed $data
2596     * @param integer $pos
2597     *
2598     * @param string $type
2599     * @param string $header
2600     * @param mixed $value
2601     *
2602     * @return int|mixed
2603     */
2604    function _write8BIM(&$data, $pos, $type, $header, &$value) {
2605        $signature = "8BIM";
2606
2607        $pos = $this->_putString($data, $pos, $signature);
2608        $pos = $this->_putShort($data, $pos, $type);
2609
2610        $len = strlen($header);
2611
2612        $pos = $this->_putByte($data, $pos, $len);
2613        $pos = $this->_putString($data, $pos, $header);
2614        if (($len % 2) == 0) {  // Even padding, including the length byte
2615            $pos = $this->_putByte($data, $pos, 0);
2616        }
2617
2618        $len = strlen($value);
2619        $pos = $this->_putLong($data, $pos, $len);
2620        $pos = $this->_putString($data, $pos, $value);
2621        if (($len % 2) != 0) {  // Even padding
2622            $pos = $this->_putByte($data, $pos, 0);
2623        }
2624        return $pos;
2625    }
2626
2627    /*************************************************************/
2628    function & _writeIPTC() {
2629        $data = " ";
2630        $pos = 0;
2631
2632        $IPTCNames =& $this->_iptcNameTags();
2633
2634        foreach($this->_info['iptc'] as $label => $value) {
2635            $value =& $this->_info['iptc'][$label];
2636            $type = -1;
2637
2638            if (isset($IPTCNames[$label])) {
2639                $type = $IPTCNames[$label];
2640            }
2641            elseif (substr($label, 0, 7) == "IPTC_0x") {
2642                $type = hexdec(substr($label, 7, 2));
2643            }
2644
2645            if ($type != -1) {
2646                if (is_array($value)) {
2647                    $vcnt = count($value);
2648                    for ($i = 0; $i < $vcnt; $i++) {
2649                        $pos = $this->_writeIPTCEntry($data, $pos, $type, $value[$i]);
2650                    }
2651                }
2652                else {
2653                    $pos = $this->_writeIPTCEntry($data, $pos, $type, $value);
2654                }
2655            }
2656        }
2657
2658        return $data;
2659    }
2660
2661    /*************************************************************/
2662
2663    /**
2664     * @param mixed $data
2665     * @param integer $pos
2666     *
2667     * @param string $type
2668     * @param mixed $value
2669     *
2670     * @return int|mixed
2671     */
2672    function _writeIPTCEntry(&$data, $pos, $type, &$value) {
2673        $pos = $this->_putShort($data, $pos, 0x1C02);
2674        $pos = $this->_putByte($data, $pos, $type);
2675        $pos = $this->_putShort($data, $pos, strlen($value));
2676        $pos = $this->_putString($data, $pos, $value);
2677
2678        return $pos;
2679    }
2680
2681    /*************************************************************/
2682    function _exifTagNames($mode) {
2683        $tags = array();
2684
2685        if ($mode == 'ifd0') {
2686            $tags[0x010E] = 'ImageDescription';
2687            $tags[0x010F] = 'Make';
2688            $tags[0x0110] = 'Model';
2689            $tags[0x0112] = 'Orientation';
2690            $tags[0x011A] = 'XResolution';
2691            $tags[0x011B] = 'YResolution';
2692            $tags[0x0128] = 'ResolutionUnit';
2693            $tags[0x0131] = 'Software';
2694            $tags[0x0132] = 'DateTime';
2695            $tags[0x013B] = 'Artist';
2696            $tags[0x013E] = 'WhitePoint';
2697            $tags[0x013F] = 'PrimaryChromaticities';
2698            $tags[0x0211] = 'YCbCrCoefficients';
2699            $tags[0x0212] = 'YCbCrSubSampling';
2700            $tags[0x0213] = 'YCbCrPositioning';
2701            $tags[0x0214] = 'ReferenceBlackWhite';
2702            $tags[0x8298] = 'Copyright';
2703            $tags[0x8769] = 'ExifIFDOffset';
2704            $tags[0x8825] = 'GPSIFDOffset';
2705        }
2706        if ($mode == 'ifd1') {
2707            $tags[0x00FE] = 'TIFFNewSubfileType';
2708            $tags[0x00FF] = 'TIFFSubfileType';
2709            $tags[0x0100] = 'TIFFImageWidth';
2710            $tags[0x0101] = 'TIFFImageHeight';
2711            $tags[0x0102] = 'TIFFBitsPerSample';
2712            $tags[0x0103] = 'TIFFCompression';
2713            $tags[0x0106] = 'TIFFPhotometricInterpretation';
2714            $tags[0x0107] = 'TIFFThreshholding';
2715            $tags[0x0108] = 'TIFFCellWidth';
2716            $tags[0x0109] = 'TIFFCellLength';
2717            $tags[0x010A] = 'TIFFFillOrder';
2718            $tags[0x010E] = 'TIFFImageDescription';
2719            $tags[0x010F] = 'TIFFMake';
2720            $tags[0x0110] = 'TIFFModel';
2721            $tags[0x0111] = 'TIFFStripOffsets';
2722            $tags[0x0112] = 'TIFFOrientation';
2723            $tags[0x0115] = 'TIFFSamplesPerPixel';
2724            $tags[0x0116] = 'TIFFRowsPerStrip';
2725            $tags[0x0117] = 'TIFFStripByteCounts';
2726            $tags[0x0118] = 'TIFFMinSampleValue';
2727            $tags[0x0119] = 'TIFFMaxSampleValue';
2728            $tags[0x011A] = 'TIFFXResolution';
2729            $tags[0x011B] = 'TIFFYResolution';
2730            $tags[0x011C] = 'TIFFPlanarConfiguration';
2731            $tags[0x0122] = 'TIFFGrayResponseUnit';
2732            $tags[0x0123] = 'TIFFGrayResponseCurve';
2733            $tags[0x0128] = 'TIFFResolutionUnit';
2734            $tags[0x0131] = 'TIFFSoftware';
2735            $tags[0x0132] = 'TIFFDateTime';
2736            $tags[0x013B] = 'TIFFArtist';
2737            $tags[0x013C] = 'TIFFHostComputer';
2738            $tags[0x0140] = 'TIFFColorMap';
2739            $tags[0x0152] = 'TIFFExtraSamples';
2740            $tags[0x0201] = 'TIFFJFIFOffset';
2741            $tags[0x0202] = 'TIFFJFIFLength';
2742            $tags[0x0211] = 'TIFFYCbCrCoefficients';
2743            $tags[0x0212] = 'TIFFYCbCrSubSampling';
2744            $tags[0x0213] = 'TIFFYCbCrPositioning';
2745            $tags[0x0214] = 'TIFFReferenceBlackWhite';
2746            $tags[0x8298] = 'TIFFCopyright';
2747            $tags[0x9286] = 'TIFFUserComment';
2748        } elseif ($mode == 'exif') {
2749            $tags[0x829A] = 'ExposureTime';
2750            $tags[0x829D] = 'FNumber';
2751            $tags[0x8822] = 'ExposureProgram';
2752            $tags[0x8824] = 'SpectralSensitivity';
2753            $tags[0x8827] = 'ISOSpeedRatings';
2754            $tags[0x8828] = 'OECF';
2755            $tags[0x9000] = 'EXIFVersion';
2756            $tags[0x9003] = 'DateTimeOriginal';
2757            $tags[0x9004] = 'DateTimeDigitized';
2758            $tags[0x9101] = 'ComponentsConfiguration';
2759            $tags[0x9102] = 'CompressedBitsPerPixel';
2760            $tags[0x9201] = 'ShutterSpeedValue';
2761            $tags[0x9202] = 'ApertureValue';
2762            $tags[0x9203] = 'BrightnessValue';
2763            $tags[0x9204] = 'ExposureBiasValue';
2764            $tags[0x9205] = 'MaxApertureValue';
2765            $tags[0x9206] = 'SubjectDistance';
2766            $tags[0x9207] = 'MeteringMode';
2767            $tags[0x9208] = 'LightSource';
2768            $tags[0x9209] = 'Flash';
2769            $tags[0x920A] = 'FocalLength';
2770            $tags[0x927C] = 'MakerNote';
2771            $tags[0x9286] = 'UserComment';
2772            $tags[0x9290] = 'SubSecTime';
2773            $tags[0x9291] = 'SubSecTimeOriginal';
2774            $tags[0x9292] = 'SubSecTimeDigitized';
2775            $tags[0xA000] = 'FlashPixVersion';
2776            $tags[0xA001] = 'ColorSpace';
2777            $tags[0xA002] = 'PixelXDimension';
2778            $tags[0xA003] = 'PixelYDimension';
2779            $tags[0xA004] = 'RelatedSoundFile';
2780            $tags[0xA005] = 'InteropIFDOffset';
2781            $tags[0xA20B] = 'FlashEnergy';
2782            $tags[0xA20C] = 'SpatialFrequencyResponse';
2783            $tags[0xA20E] = 'FocalPlaneXResolution';
2784            $tags[0xA20F] = 'FocalPlaneYResolution';
2785            $tags[0xA210] = 'FocalPlaneResolutionUnit';
2786            $tags[0xA214] = 'SubjectLocation';
2787            $tags[0xA215] = 'ExposureIndex';
2788            $tags[0xA217] = 'SensingMethod';
2789            $tags[0xA300] = 'FileSource';
2790            $tags[0xA301] = 'SceneType';
2791            $tags[0xA302] = 'CFAPattern';
2792        } elseif ($mode == 'interop') {
2793            $tags[0x0001] = 'InteroperabilityIndex';
2794            $tags[0x0002] = 'InteroperabilityVersion';
2795            $tags[0x1000] = 'RelatedImageFileFormat';
2796            $tags[0x1001] = 'RelatedImageWidth';
2797            $tags[0x1002] = 'RelatedImageLength';
2798        } elseif ($mode == 'gps') {
2799            $tags[0x0000] = 'GPSVersionID';
2800            $tags[0x0001] = 'GPSLatitudeRef';
2801            $tags[0x0002] = 'GPSLatitude';
2802            $tags[0x0003] = 'GPSLongitudeRef';
2803            $tags[0x0004] = 'GPSLongitude';
2804            $tags[0x0005] = 'GPSAltitudeRef';
2805            $tags[0x0006] = 'GPSAltitude';
2806            $tags[0x0007] = 'GPSTimeStamp';
2807            $tags[0x0008] = 'GPSSatellites';
2808            $tags[0x0009] = 'GPSStatus';
2809            $tags[0x000A] = 'GPSMeasureMode';
2810            $tags[0x000B] = 'GPSDOP';
2811            $tags[0x000C] = 'GPSSpeedRef';
2812            $tags[0x000D] = 'GPSSpeed';
2813            $tags[0x000E] = 'GPSTrackRef';
2814            $tags[0x000F] = 'GPSTrack';
2815            $tags[0x0010] = 'GPSImgDirectionRef';
2816            $tags[0x0011] = 'GPSImgDirection';
2817            $tags[0x0012] = 'GPSMapDatum';
2818            $tags[0x0013] = 'GPSDestLatitudeRef';
2819            $tags[0x0014] = 'GPSDestLatitude';
2820            $tags[0x0015] = 'GPSDestLongitudeRef';
2821            $tags[0x0016] = 'GPSDestLongitude';
2822            $tags[0x0017] = 'GPSDestBearingRef';
2823            $tags[0x0018] = 'GPSDestBearing';
2824            $tags[0x0019] = 'GPSDestDistanceRef';
2825            $tags[0x001A] = 'GPSDestDistance';
2826        }
2827
2828        return $tags;
2829    }
2830
2831    /*************************************************************/
2832    function _exifTagTypes($mode) {
2833        $tags = array();
2834
2835        if ($mode == 'ifd0') {
2836            $tags[0x010E] = array(2, 0); // ImageDescription -> ASCII, Any
2837            $tags[0x010F] = array(2, 0); // Make -> ASCII, Any
2838            $tags[0x0110] = array(2, 0); // Model -> ASCII, Any
2839            $tags[0x0112] = array(3, 1); // Orientation -> SHORT, 1
2840            $tags[0x011A] = array(5, 1); // XResolution -> RATIONAL, 1
2841            $tags[0x011B] = array(5, 1); // YResolution -> RATIONAL, 1
2842            $tags[0x0128] = array(3, 1); // ResolutionUnit -> SHORT
2843            $tags[0x0131] = array(2, 0); // Software -> ASCII, Any
2844            $tags[0x0132] = array(2, 20); // DateTime -> ASCII, 20
2845            $tags[0x013B] = array(2, 0); // Artist -> ASCII, Any
2846            $tags[0x013E] = array(5, 2); // WhitePoint -> RATIONAL, 2
2847            $tags[0x013F] = array(5, 6); // PrimaryChromaticities -> RATIONAL, 6
2848            $tags[0x0211] = array(5, 3); // YCbCrCoefficients -> RATIONAL, 3
2849            $tags[0x0212] = array(3, 2); // YCbCrSubSampling -> SHORT, 2
2850            $tags[0x0213] = array(3, 1); // YCbCrPositioning -> SHORT, 1
2851            $tags[0x0214] = array(5, 6); // ReferenceBlackWhite -> RATIONAL, 6
2852            $tags[0x8298] = array(2, 0); // Copyright -> ASCII, Any
2853            $tags[0x8769] = array(4, 1); // ExifIFDOffset -> LONG, 1
2854            $tags[0x8825] = array(4, 1); // GPSIFDOffset -> LONG, 1
2855        }
2856        if ($mode == 'ifd1') {
2857            $tags[0x00FE] = array(4, 1); // TIFFNewSubfileType -> LONG, 1
2858            $tags[0x00FF] = array(3, 1); // TIFFSubfileType -> SHORT, 1
2859            $tags[0x0100] = array(4, 1); // TIFFImageWidth -> LONG (or SHORT), 1
2860            $tags[0x0101] = array(4, 1); // TIFFImageHeight -> LONG (or SHORT), 1
2861            $tags[0x0102] = array(3, 3); // TIFFBitsPerSample -> SHORT, 3
2862            $tags[0x0103] = array(3, 1); // TIFFCompression -> SHORT, 1
2863            $tags[0x0106] = array(3, 1); // TIFFPhotometricInterpretation -> SHORT, 1
2864            $tags[0x0107] = array(3, 1); // TIFFThreshholding -> SHORT, 1
2865            $tags[0x0108] = array(3, 1); // TIFFCellWidth -> SHORT, 1
2866            $tags[0x0109] = array(3, 1); // TIFFCellLength -> SHORT, 1
2867            $tags[0x010A] = array(3, 1); // TIFFFillOrder -> SHORT, 1
2868            $tags[0x010E] = array(2, 0); // TIFFImageDescription -> ASCII, Any
2869            $tags[0x010F] = array(2, 0); // TIFFMake -> ASCII, Any
2870            $tags[0x0110] = array(2, 0); // TIFFModel -> ASCII, Any
2871            $tags[0x0111] = array(4, 0); // TIFFStripOffsets -> LONG (or SHORT), Any (one per strip)
2872            $tags[0x0112] = array(3, 1); // TIFFOrientation -> SHORT, 1
2873            $tags[0x0115] = array(3, 1); // TIFFSamplesPerPixel -> SHORT, 1
2874            $tags[0x0116] = array(4, 1); // TIFFRowsPerStrip -> LONG (or SHORT), 1
2875            $tags[0x0117] = array(4, 0); // TIFFStripByteCounts -> LONG (or SHORT), Any (one per strip)
2876            $tags[0x0118] = array(3, 0); // TIFFMinSampleValue -> SHORT, Any (SamplesPerPixel)
2877            $tags[0x0119] = array(3, 0); // TIFFMaxSampleValue -> SHORT, Any (SamplesPerPixel)
2878            $tags[0x011A] = array(5, 1); // TIFFXResolution -> RATIONAL, 1
2879            $tags[0x011B] = array(5, 1); // TIFFYResolution -> RATIONAL, 1
2880            $tags[0x011C] = array(3, 1); // TIFFPlanarConfiguration -> SHORT, 1
2881            $tags[0x0122] = array(3, 1); // TIFFGrayResponseUnit -> SHORT, 1
2882            $tags[0x0123] = array(3, 0); // TIFFGrayResponseCurve -> SHORT, Any (2^BitsPerSample)
2883            $tags[0x0128] = array(3, 1); // TIFFResolutionUnit -> SHORT, 1
2884            $tags[0x0131] = array(2, 0); // TIFFSoftware -> ASCII, Any
2885            $tags[0x0132] = array(2, 20); // TIFFDateTime -> ASCII, 20
2886            $tags[0x013B] = array(2, 0); // TIFFArtist -> ASCII, Any
2887            $tags[0x013C] = array(2, 0); // TIFFHostComputer -> ASCII, Any
2888            $tags[0x0140] = array(3, 0); // TIFFColorMap -> SHORT, Any (3 * 2^BitsPerSample)
2889            $tags[0x0152] = array(3, 0); // TIFFExtraSamples -> SHORT, Any (SamplesPerPixel - 3)
2890            $tags[0x0201] = array(4, 1); // TIFFJFIFOffset -> LONG, 1
2891            $tags[0x0202] = array(4, 1); // TIFFJFIFLength -> LONG, 1
2892            $tags[0x0211] = array(5, 3); // TIFFYCbCrCoefficients -> RATIONAL, 3
2893            $tags[0x0212] = array(3, 2); // TIFFYCbCrSubSampling -> SHORT, 2
2894            $tags[0x0213] = array(3, 1); // TIFFYCbCrPositioning -> SHORT, 1
2895            $tags[0x0214] = array(5, 6); // TIFFReferenceBlackWhite -> RATIONAL, 6
2896            $tags[0x8298] = array(2, 0); // TIFFCopyright -> ASCII, Any
2897            $tags[0x9286] = array(2, 0); // TIFFUserComment -> ASCII, Any
2898        } elseif ($mode == 'exif') {
2899            $tags[0x829A] = array(5, 1); // ExposureTime -> RATIONAL, 1
2900            $tags[0x829D] = array(5, 1); // FNumber -> RATIONAL, 1
2901            $tags[0x8822] = array(3, 1); // ExposureProgram -> SHORT, 1
2902            $tags[0x8824] = array(2, 0); // SpectralSensitivity -> ASCII, Any
2903            $tags[0x8827] = array(3, 0); // ISOSpeedRatings -> SHORT, Any
2904            $tags[0x8828] = array(7, 0); // OECF -> UNDEFINED, Any
2905            $tags[0x9000] = array(7, 4); // EXIFVersion -> UNDEFINED, 4
2906            $tags[0x9003] = array(2, 20); // DateTimeOriginal -> ASCII, 20
2907            $tags[0x9004] = array(2, 20); // DateTimeDigitized -> ASCII, 20
2908            $tags[0x9101] = array(7, 4); // ComponentsConfiguration -> UNDEFINED, 4
2909            $tags[0x9102] = array(5, 1); // CompressedBitsPerPixel -> RATIONAL, 1
2910            $tags[0x9201] = array(10, 1); // ShutterSpeedValue -> SRATIONAL, 1
2911            $tags[0x9202] = array(5, 1); // ApertureValue -> RATIONAL, 1
2912            $tags[0x9203] = array(10, 1); // BrightnessValue -> SRATIONAL, 1
2913            $tags[0x9204] = array(10, 1); // ExposureBiasValue -> SRATIONAL, 1
2914            $tags[0x9205] = array(5, 1); // MaxApertureValue -> RATIONAL, 1
2915            $tags[0x9206] = array(5, 1); // SubjectDistance -> RATIONAL, 1
2916            $tags[0x9207] = array(3, 1); // MeteringMode -> SHORT, 1
2917            $tags[0x9208] = array(3, 1); // LightSource -> SHORT, 1
2918            $tags[0x9209] = array(3, 1); // Flash -> SHORT, 1
2919            $tags[0x920A] = array(5, 1); // FocalLength -> RATIONAL, 1
2920            $tags[0x927C] = array(7, 0); // MakerNote -> UNDEFINED, Any
2921            $tags[0x9286] = array(7, 0); // UserComment -> UNDEFINED, Any
2922            $tags[0x9290] = array(2, 0); // SubSecTime -> ASCII, Any
2923            $tags[0x9291] = array(2, 0); // SubSecTimeOriginal -> ASCII, Any
2924            $tags[0x9292] = array(2, 0); // SubSecTimeDigitized -> ASCII, Any
2925            $tags[0xA000] = array(7, 4); // FlashPixVersion -> UNDEFINED, 4
2926            $tags[0xA001] = array(3, 1); // ColorSpace -> SHORT, 1
2927            $tags[0xA002] = array(4, 1); // PixelXDimension -> LONG (or SHORT), 1
2928            $tags[0xA003] = array(4, 1); // PixelYDimension -> LONG (or SHORT), 1
2929            $tags[0xA004] = array(2, 13); // RelatedSoundFile -> ASCII, 13
2930            $tags[0xA005] = array(4, 1); // InteropIFDOffset -> LONG, 1
2931            $tags[0xA20B] = array(5, 1); // FlashEnergy -> RATIONAL, 1
2932            $tags[0xA20C] = array(7, 0); // SpatialFrequencyResponse -> UNDEFINED, Any
2933            $tags[0xA20E] = array(5, 1); // FocalPlaneXResolution -> RATIONAL, 1
2934            $tags[0xA20F] = array(5, 1); // FocalPlaneYResolution -> RATIONAL, 1
2935            $tags[0xA210] = array(3, 1); // FocalPlaneResolutionUnit -> SHORT, 1
2936            $tags[0xA214] = array(3, 2); // SubjectLocation -> SHORT, 2
2937            $tags[0xA215] = array(5, 1); // ExposureIndex -> RATIONAL, 1
2938            $tags[0xA217] = array(3, 1); // SensingMethod -> SHORT, 1
2939            $tags[0xA300] = array(7, 1); // FileSource -> UNDEFINED, 1
2940            $tags[0xA301] = array(7, 1); // SceneType -> UNDEFINED, 1
2941            $tags[0xA302] = array(7, 0); // CFAPattern -> UNDEFINED, Any
2942        } elseif ($mode == 'interop') {
2943            $tags[0x0001] = array(2, 0); // InteroperabilityIndex -> ASCII, Any
2944            $tags[0x0002] = array(7, 4); // InteroperabilityVersion -> UNKNOWN, 4
2945            $tags[0x1000] = array(2, 0); // RelatedImageFileFormat -> ASCII, Any
2946            $tags[0x1001] = array(4, 1); // RelatedImageWidth -> LONG (or SHORT), 1
2947            $tags[0x1002] = array(4, 1); // RelatedImageLength -> LONG (or SHORT), 1
2948        } elseif ($mode == 'gps') {
2949            $tags[0x0000] = array(1, 4); // GPSVersionID -> BYTE, 4
2950            $tags[0x0001] = array(2, 2); // GPSLatitudeRef -> ASCII, 2
2951            $tags[0x0002] = array(5, 3); // GPSLatitude -> RATIONAL, 3
2952            $tags[0x0003] = array(2, 2); // GPSLongitudeRef -> ASCII, 2
2953            $tags[0x0004] = array(5, 3); // GPSLongitude -> RATIONAL, 3
2954            $tags[0x0005] = array(2, 2); // GPSAltitudeRef -> ASCII, 2
2955            $tags[0x0006] = array(5, 1); // GPSAltitude -> RATIONAL, 1
2956            $tags[0x0007] = array(5, 3); // GPSTimeStamp -> RATIONAL, 3
2957            $tags[0x0008] = array(2, 0); // GPSSatellites -> ASCII, Any
2958            $tags[0x0009] = array(2, 2); // GPSStatus -> ASCII, 2
2959            $tags[0x000A] = array(2, 2); // GPSMeasureMode -> ASCII, 2
2960            $tags[0x000B] = array(5, 1); // GPSDOP -> RATIONAL, 1
2961            $tags[0x000C] = array(2, 2); // GPSSpeedRef -> ASCII, 2
2962            $tags[0x000D] = array(5, 1); // GPSSpeed -> RATIONAL, 1
2963            $tags[0x000E] = array(2, 2); // GPSTrackRef -> ASCII, 2
2964            $tags[0x000F] = array(5, 1); // GPSTrack -> RATIONAL, 1
2965            $tags[0x0010] = array(2, 2); // GPSImgDirectionRef -> ASCII, 2
2966            $tags[0x0011] = array(5, 1); // GPSImgDirection -> RATIONAL, 1
2967            $tags[0x0012] = array(2, 0); // GPSMapDatum -> ASCII, Any
2968            $tags[0x0013] = array(2, 2); // GPSDestLatitudeRef -> ASCII, 2
2969            $tags[0x0014] = array(5, 3); // GPSDestLatitude -> RATIONAL, 3
2970            $tags[0x0015] = array(2, 2); // GPSDestLongitudeRef -> ASCII, 2
2971            $tags[0x0016] = array(5, 3); // GPSDestLongitude -> RATIONAL, 3
2972            $tags[0x0017] = array(2, 2); // GPSDestBearingRef -> ASCII, 2
2973            $tags[0x0018] = array(5, 1); // GPSDestBearing -> RATIONAL, 1
2974            $tags[0x0019] = array(2, 2); // GPSDestDistanceRef -> ASCII, 2
2975            $tags[0x001A] = array(5, 1); // GPSDestDistance -> RATIONAL, 1
2976        }
2977
2978        return $tags;
2979    }
2980
2981    /*************************************************************/
2982    function _exifNameTags($mode) {
2983        $tags = $this->_exifTagNames($mode);
2984        return $this->_names2Tags($tags);
2985    }
2986
2987    /*************************************************************/
2988    function _iptcTagNames() {
2989        $tags = array();
2990        $tags[0x14] = 'SuplementalCategories';
2991        $tags[0x19] = 'Keywords';
2992        $tags[0x78] = 'Caption';
2993        $tags[0x7A] = 'CaptionWriter';
2994        $tags[0x69] = 'Headline';
2995        $tags[0x28] = 'SpecialInstructions';
2996        $tags[0x0F] = 'Category';
2997        $tags[0x50] = 'Byline';
2998        $tags[0x55] = 'BylineTitle';
2999        $tags[0x6E] = 'Credit';
3000        $tags[0x73] = 'Source';
3001        $tags[0x74] = 'CopyrightNotice';
3002        $tags[0x05] = 'ObjectName';
3003        $tags[0x5A] = 'City';
3004        $tags[0x5C] = 'Sublocation';
3005        $tags[0x5F] = 'ProvinceState';
3006        $tags[0x65] = 'CountryName';
3007        $tags[0x67] = 'OriginalTransmissionReference';
3008        $tags[0x37] = 'DateCreated';
3009        $tags[0x0A] = 'CopyrightFlag';
3010
3011        return $tags;
3012    }
3013
3014    /*************************************************************/
3015    function & _iptcNameTags() {
3016        $tags = $this->_iptcTagNames();
3017        return $this->_names2Tags($tags);
3018    }
3019
3020    /*************************************************************/
3021    function _names2Tags($tags2Names) {
3022        $names2Tags = array();
3023
3024        foreach($tags2Names as $tag => $name) {
3025            $names2Tags[$name] = $tag;
3026        }
3027
3028        return $names2Tags;
3029    }
3030
3031    /*************************************************************/
3032
3033    /**
3034     * @param $data
3035     * @param integer $pos
3036     *
3037     * @return int
3038     */
3039    function _getByte(&$data, $pos) {
3040        if (!isset($data[$pos])) {
3041            throw new Exception("Requested byte at ".$pos.". Reading outside of file's boundaries.");
3042        }
3043
3044        return ord($data[$pos]);
3045    }
3046
3047    /*************************************************************/
3048
3049    /**
3050     * @param mixed $data
3051     * @param integer $pos
3052     *
3053     * @param mixed $val
3054     *
3055     * @return int
3056     */
3057    function _putByte(&$data, $pos, $val) {
3058        $val = intval($val);
3059
3060        $data[$pos] = chr($val);
3061
3062        return $pos + 1;
3063    }
3064
3065    /*************************************************************/
3066    function _getShort(&$data, $pos, $bigEndian = true) {
3067        if (!isset($data[$pos]) || !isset($data[$pos + 1])) {
3068            throw new Exception("Requested short at ".$pos.". Reading outside of file's boundaries.");
3069        }
3070
3071        if ($bigEndian) {
3072            return (ord($data[$pos]) << 8)
3073                + ord($data[$pos + 1]);
3074        } else {
3075            return ord($data[$pos])
3076                + (ord($data[$pos + 1]) << 8);
3077        }
3078    }
3079
3080    /*************************************************************/
3081    function _putShort(&$data, $pos = 0, $val = 0, $bigEndian = true) {
3082        $val = intval($val);
3083
3084        if ($bigEndian) {
3085            $data[$pos + 0] = chr(($val & 0x0000FF00) >> 8);
3086            $data[$pos + 1] = chr(($val & 0x000000FF) >> 0);
3087        } else {
3088            $data[$pos + 0] = chr(($val & 0x00FF) >> 0);
3089            $data[$pos + 1] = chr(($val & 0xFF00) >> 8);
3090        }
3091
3092        return $pos + 2;
3093    }
3094
3095    /*************************************************************/
3096
3097    /**
3098     * @param mixed $data
3099     * @param integer $pos
3100     *
3101     * @param bool $bigEndian
3102     *
3103     * @return int
3104     */
3105    function _getLong(&$data, $pos, $bigEndian = true) {
3106        // Assume that if the start and end bytes are defined, the bytes inbetween are defined as well.
3107        if (!isset($data[$pos]) || !isset($data[$pos + 3])){
3108            throw new Exception("Requested long at ".$pos.". Reading outside of file's boundaries.");
3109        }
3110        if ($bigEndian) {
3111            return (ord($data[$pos]) << 24)
3112                + (ord($data[$pos + 1]) << 16)
3113                + (ord($data[$pos + 2]) << 8)
3114                + ord($data[$pos + 3]);
3115        } else {
3116            return ord($data[$pos])
3117                + (ord($data[$pos + 1]) << 8)
3118                + (ord($data[$pos + 2]) << 16)
3119                + (ord($data[$pos + 3]) << 24);
3120        }
3121    }
3122
3123    /*************************************************************/
3124
3125    /**
3126     * @param mixed $data
3127     * @param integer $pos
3128     *
3129     * @param mixed $val
3130     * @param bool $bigEndian
3131     *
3132     * @return int
3133     */
3134    function _putLong(&$data, $pos, $val, $bigEndian = true) {
3135        $val = intval($val);
3136
3137        if ($bigEndian) {
3138            $data[$pos + 0] = chr(($val & 0xFF000000) >> 24);
3139            $data[$pos + 1] = chr(($val & 0x00FF0000) >> 16);
3140            $data[$pos + 2] = chr(($val & 0x0000FF00) >> 8);
3141            $data[$pos + 3] = chr(($val & 0x000000FF) >> 0);
3142        } else {
3143            $data[$pos + 0] = chr(($val & 0x000000FF) >> 0);
3144            $data[$pos + 1] = chr(($val & 0x0000FF00) >> 8);
3145            $data[$pos + 2] = chr(($val & 0x00FF0000) >> 16);
3146            $data[$pos + 3] = chr(($val & 0xFF000000) >> 24);
3147        }
3148
3149        return $pos + 4;
3150    }
3151
3152    /*************************************************************/
3153    function & _getNullString(&$data, $pos) {
3154        $str = '';
3155        $max = strlen($data);
3156
3157        while ($pos < $max) {
3158            if (!isset($data[$pos])) {
3159                throw new Exception("Requested null-terminated string at offset ".$pos.". File terminated before the null-byte.");
3160            }
3161            if (ord($data[$pos]) == 0) {
3162                return $str;
3163            } else {
3164                $str .= $data[$pos];
3165            }
3166            $pos++;
3167        }
3168
3169        return $str;
3170    }
3171
3172    /*************************************************************/
3173    function & _getFixedString(&$data, $pos, $length = -1) {
3174        if ($length == -1) {
3175            $length = strlen($data) - $pos;
3176        }
3177
3178        $rv = substr($data, $pos, $length);
3179        if (strlen($rv) != $length) {
3180            throw new ErrorException(sprintf(
3181                "JPEGMeta failed parsing image metadata of %s. Got %d instead of %d bytes at offset %d.",
3182                $this->_fileName, strlen($rv), $length, $pos
3183            ), 0, E_WARNING);
3184        }
3185        return $rv;
3186    }
3187
3188    /*************************************************************/
3189    function _putString(&$data, $pos, &$str) {
3190        $len = strlen($str);
3191        for ($i = 0; $i < $len; $i++) {
3192            $data[$pos + $i] = $str[$i];
3193        }
3194
3195        return $pos + $len;
3196    }
3197
3198    /*************************************************************/
3199    function _hexDump(&$data, $start = 0, $length = -1) {
3200        if (($length == -1) || (($length + $start) > strlen($data))) {
3201            $end = strlen($data);
3202        } else {
3203            $end = $start + $length;
3204        }
3205
3206        $ascii = '';
3207        $count = 0;
3208
3209        echo "<tt>\n";
3210
3211        while ($start < $end) {
3212            if (($count % 16) == 0) {
3213                echo sprintf('%04d', $count) . ': ';
3214            }
3215
3216            $c = ord($data[$start]);
3217            $count++;
3218            $start++;
3219
3220            $aux = dechex($c);
3221            if (strlen($aux) == 1)
3222                echo '0';
3223            echo $aux . ' ';
3224
3225            if ($c == 60)
3226                $ascii .= '&lt;';
3227            elseif ($c == 62)
3228                $ascii .= '&gt;';
3229            elseif ($c == 32)
3230                $ascii .= '&#160;';
3231            elseif ($c > 32)
3232                $ascii .= chr($c);
3233            else
3234                $ascii .= '.';
3235
3236            if (($count % 4) == 0) {
3237                echo ' - ';
3238            }
3239
3240            if (($count % 16) == 0) {
3241                echo ': ' . $ascii . "<br>\n";
3242                $ascii = '';
3243            }
3244        }
3245
3246        if ($ascii != '') {
3247            while (($count % 16) != 0) {
3248                echo '-- ';
3249                $count++;
3250                if (($count % 4) == 0) {
3251                    echo ' - ';
3252                }
3253            }
3254            echo ': ' . $ascii . "<br>\n";
3255        }
3256
3257        echo "</tt>\n";
3258    }
3259
3260    /*****************************************************************/
3261}
3262
3263/* vim: set expandtab tabstop=4 shiftwidth=4: */
3264