Changeset 4698


Ignore:
Timestamp:
01/17/10 19:05:35 (10 years ago)
Author:
grum
Message:

[Plugin:AMetaData] Finished to comment the JpegMetaData classes and rename some methods

Location:
extensions/AMetaData/JpegMetaData
Files:
1 deleted
20 edited

Legend:

Unmodified
Added
Removed
  • extensions/AMetaData/JpegMetaData/Common/Locale.class.php

    r4686 r4698  
    3535 * The Locale class is used for tag translation, reading the .mo files 
    3636 * 
     37 * There is one directory per language, the directories tree must respect this 
     38 * structure 
     39 * 
     40 * --\ Locale                           => main directory for languages 
     41 *     | 
     42 *     +--\ en_UK                       => language 
     43 *     |    | 
     44 *     |    +--\ LC_MESSAGES 
     45 *     |         | 
     46 *     |         +--\ Tag.mo            => names & values translations 
     47 *     |         +--\ TadDesc.mo        => descriptions translations 
     48 *     | 
     49 *     +--\ fr_FR 
     50 *          | 
     51 *          +--\ LC_MESSAGES 
     52 *               | 
     53 *               +--\ Tag.mo 
     54 *               +--\ TadDesc.mo 
     55 * 
     56 * 
    3757 * ----------------------------------------------------------------------------- 
    3858 * 
     59 * .. Notes .. 
     60 * 
     61 * This class don't use the PHP gettext functions, but the php-gettext extension 
     62 * ==> See files in External/php-gettext for more information about this project 
     63 * 
     64 * 
     65 * 
     66 * This class provides theses public functions : 
     67 *  - (static) setLanguage 
     68 *  - (static) getLanguage 
     69 *  - (static) get 
     70 *  - (static) getDesc 
    3971 * 
    4072 * ----------------------------------------------------------------------------- 
     
    4476require_once(JPEG_METADATA_DIR."External/php-gettext/gettext.inc"); 
    4577 
    46 $supported_locales = array('en_UK'); 
     78/** 
     79 * $supported_locales is a global variable need by the php-gettext package. 
     80 * the array is automatically initialized with the setLanguage() function 
     81 */ 
     82$supported_locales = array(); 
     83 
     84/** 
     85 * assume a default language is set in any case... 
     86 */ 
     87Locale::setLanguage(); 
     88 
    4789 
    4890class Locale 
     
    5193  const JMD_TAGDESC = "TagDesc"; 
    5294 
    53   static function set($language) 
     95  static private $language = ""; 
     96 
     97  /** 
     98   * This function is used to set the locale language. 
     99   * If no language is given, assume the default "en_UK" language 
     100   * 
     101   * If there is no translation file for the the given language, assume the 
     102   * default "en_UK" language 
     103   * 
     104   * @param String $language : the language 
     105   * @return String : the defined language 
     106   */ 
     107  static function setLanguage($language="en_UK") 
    54108  { 
    55     T_setlocale(LC_MESSAGES, $language); 
     109    global $supported_locales; 
    56110 
     111    /* 
     112     * Scan the Locale directory. 
     113     * Any directory with a sub directory "LC_MESSAGES" is considered as a 
     114     * supported locale language 
     115     */ 
     116    $directory=scandir(JPEG_METADATA_DIR."Locale"); 
     117    foreach($directory as $key => $file) 
     118    { 
     119      if(is_dir(JPEG_METADATA_DIR."Locale/".$file) and 
     120         $file!='.' and 
     121         $file!='..' and 
     122         file_exists(JPEG_METADATA_DIR."Locale/".$file."/LC_MESSAGES/Tag.mo")) 
     123         $supported_locales[]=$file; 
     124 
     125    } 
     126 
     127    /* 
     128     * if the desired language doesn't exist, apply the en_UK locale 
     129     * (assuming the en_UK exists and was not deleted) 
     130     */ 
     131    if(!in_array($language, $supported_locales)) 
     132      self::$language='en_UK'; 
     133    else 
     134      self::$language=$language; 
     135 
     136    /* 
     137     * set the locale 
     138     */ 
     139    T_setlocale(LC_MESSAGES, self::$language); 
     140 
     141    /* 
     142     * set one domain "TAG" for tags name&values, and one domaine "TAGDESC" for 
     143     * tags description 
     144     */ 
    57145    T_bindtextdomain(self::JMD_TAG, dirname(dirname(__FILE__))."/Locale"); 
    58146    T_bindtextdomain(self::JMD_TAGDESC, dirname(dirname(__FILE__))."/Locale"); 
     147 
     148    return(self::$language); 
    59149  } 
    60150 
    61   static function get($tagName) 
     151  /** 
     152   * returns the defined current language 
     153   * 
     154   * @return String 
     155   */ 
     156  static function getLanguage() 
    62157  { 
    63     return(@T_dgettext(self::JMD_TAG, $tagName)); 
     158    return(self::$language); 
    64159  } 
    65160 
     161  /** 
     162   * returns the translation in current language for the given key 
     163   * 
     164   * @return String 
     165   */ 
     166  static function get($key) 
     167  { 
     168    return(@T_dgettext(self::JMD_TAG, $key)); 
     169  } 
     170 
     171  /** 
     172   * returns the description in current language for the given tagName 
     173   * 
     174   * @return String 
     175   */ 
    66176  static function getDesc($tagName) 
    67177  { 
  • extensions/AMetaData/JpegMetaData/Common/Tag.class.php

    r4686 r4698  
    5858 *  - getValue 
    5959 *  - getLabel 
    60  *  - getIsKnown 
    61  *  - getIsImplemented 
    6260 *  - getNote 
    63  *  - getIsTranslatable 
     61 *  - isKnown 
     62 *  - isImplemented 
     63 *  - isTranslatable 
    6464 *  - setId 
    6565 *  - setName 
    6666 *  - setValue 
    6767 *  - setLabel 
    68  *  - setIsKnown 
    69  *  - setIsImplemented 
    7068 *  - setNote 
    71  *  - setIsTranslatable 
     69 *  - setKnown 
     70 *  - setImplemented 
     71 *  - setTranslatable 
    7272 * 
    7373 * ----------------------------------------------------------------------------- 
     
    164164     * @return Boolean 
    165165     */ 
    166     public function getIsKnown() 
     166    public function isKnown() 
    167167    { 
    168168      return($this->tagIsKnown); 
     
    174174     * @return Boolean 
    175175     */ 
    176     public function getIsImplemented() 
     176    public function isImplemented() 
    177177    { 
    178178      return($this->tagIsImplemented); 
     
    194194     * @return Boolean 
    195195     */ 
    196     public function getIsTranslatable() 
     196    public function isTranslatable() 
    197197    { 
    198198      return($this->tagIsTranslatable); 
     
    207207    public function setId($value) 
    208208    { 
    209       if($value>=0x0000 and $value <= 0xffff) $this->tagId=$value; 
     209      $this->tagId=$value; 
    210210      return($this->tagId); 
    211211    } 
     
    253253     * @return Boolean 
    254254     */ 
    255     public function setIsKnown($value) 
     255    public function setKnown($value) 
    256256    { 
    257257      $this->tagIsKnown=($value===true)?true:false; 
     
    265265     * @return Boolean 
    266266     */ 
    267     public function setIsImplemented($value) 
     267    public function setImplemented($value) 
    268268    { 
    269269      $this->tagIsImplemented=($value===true)?true:false; 
     
    289289     * @return Boolean 
    290290     */ 
    291     public function setIsTranslatable($value) 
     291    public function setTranslatable($value) 
    292292    { 
    293293      $this->tagIsTranslatable=($value===true)?true:false; 
  • extensions/AMetaData/JpegMetaData/JpegMetaData.class.php

    r4686 r4698  
    433433      foreach($this->tags as $key => $val) 
    434434      { 
    435         if(self::filter($val->getIsKnown(), $val->getIsImplemented(), $tagFilter)) 
     435        if(self::filter($val->isKnown(), $val->isImplemented(), $tagFilter)) 
    436436        { 
    437437          $returned[$key]=$val; 
     
    477477      foreach($ifd->getTags() as $key => $tag) 
    478478      { 
    479         if(self::filter($tag->getTag()->getIsKnown(), $tag->getTag()->getIsImplemented(), $this->options['filter'])) 
     479        if(self::filter($tag->getTag()->isKnown(), $tag->getTag()->isImplemented(), $this->options['filter'])) 
    480480        { 
    481481          if($tag->getTag()->getLabel() instanceof IfdReader) 
     
    519519      foreach($tags as $key => $tag) 
    520520      { 
    521         if(self::filter($tag->getIsKnown(), $tag->getIsImplemented(), $this->options['filter'])) 
     521        if(self::filter($tag->isKnown(), $tag->isImplemented(), $this->options['filter'])) 
    522522        { 
    523523          $this->tags[$tagKey.".".$tag->getName()]=$tag; 
  • extensions/AMetaData/JpegMetaData/Locale/en_UK/Tag.po

    r4686 r4698  
    12771277#. Pentax specific tags / 0x000e (AFPoint) 
    12781278msgid "Left" 
    1279 msgstr "****Left" 
     1279msgstr "Left" 
    12801280 
    12811281#. Pentax specific tags / 0x0207 (LensInfo) 
  • extensions/AMetaData/JpegMetaData/Readers/GenericReader.class.php

    r4686 r4698  
    111111    /** 
    112112     * returns a Tag object from a sequential index 
     113     * return null if index is out of range 
    113114     * 
    114115     * @return Tag 
     
    116117    public function getTag($index) 
    117118    { 
    118       return($this->entries[$index]); 
     119      if($index>=0 and $index<=count($this->entries)) 
     120        return($this->entries[$index]); 
     121      else 
     122        return(null); 
    119123    } 
    120124 
     
    140144      for($i=0;$i<count($this->entries);$i++) 
    141145      { 
    142         if($this->entries[$i]->getId()==$tagId) 
    143         { 
    144           return($i); 
     146        if($this->entries[$i] instanceof IfdEntryReader) 
     147        { 
     148          if($this->entries[$i]->getTagId()==$tagId) 
     149          { 
     150            return($i); 
     151          } 
     152        } 
     153        elseif($this->entries[$i] instanceof Tag) 
     154        { 
     155          if($this->entries[$i]->getId()==$tagId) 
     156          { 
     157            return($i); 
     158          } 
    145159        } 
    146160      } 
     
    176190      for($i=0;$i<count($this->entries);$i++) 
    177191      { 
    178         if($this->entries[$i]->getName()==$name) 
    179         { 
    180           return($this->entries[$i]); 
     192        if($this->entries[$i] instanceof IfdEntryReader) 
     193        { 
     194          if($this->entries[$i]->getTag()->getName()==$name) 
     195          { 
     196            return($this->entries[$i]->getTag()); 
     197          } 
     198        } 
     199        elseif($this->entries[$i] instanceof Tag) 
     200        { 
     201          if($this->entries[$i]->getName()==$name) 
     202          { 
     203            return($this->entries[$i]); 
     204          } 
    181205        } 
    182206      } 
  • extensions/AMetaData/JpegMetaData/Readers/HeightBIMReader.class.php

    r4686 r4698  
    5555 *  - getSize 
    5656 *  - getBlockSize 
     57 *  - getName 
    5758 * 
    5859 * ----------------------------------------------------------------------------- 
  • extensions/AMetaData/JpegMetaData/Readers/IfdReader.class.php

    r4686 r4698  
    219219        $tag=$this->tagDef->getTagById($entry->getTagId()); 
    220220 
    221         $entry->getTag()->setIsKnown(true); 
     221        $entry->getTag()->setKnown(true); 
    222222        $entry->getTag()->setName($tag['tagName']); 
    223         $entry->getTag()->setIsImplemented($tag['implemented']); 
    224         $entry->getTag()->setIsTranslatable($tag['translatable']); 
     223        $entry->getTag()->setImplemented($tag['implemented']); 
     224        $entry->getTag()->setTranslatable($tag['translatable']); 
    225225 
    226226        /* 
  • extensions/AMetaData/JpegMetaData/Readers/IptcReader.class.php

    r4686 r4698  
    220220        $tagProperties=$this->tagDef->getTagById($tag->getId()); 
    221221 
    222         $tag->setIsKnown(true); 
     222        $tag->setKnown(true); 
    223223        $tag->setName($tagProperties['tagName']); 
    224         $tag->setIsImplemented($tagProperties['implemented']); 
    225         $tag->setIsTranslatable($tagProperties['translatable']); 
     224        $tag->setImplemented($tagProperties['implemented']); 
     225        $tag->setTranslatable($tagProperties['translatable']); 
    226226 
    227227        /* 
  • extensions/AMetaData/JpegMetaData/Readers/MakerNotesReader.class.php

    r4686 r4698  
    3333 * ----------------------------------------------------------------------------- 
    3434 * 
    35  * The MakerNotesReader class is dedicated to read tags from the maker note sub 
    36  * IFD structure 
     35 * The exif tag 0x927C "MakerNote" is a tag used by the camera maker to manage 
     36 * their own data. 
     37 * 
     38 * In most of case, this tags gives an offset to an extra data block. 
     39 * And in most of case, this data block is a sub-IFD block 
     40 * 
     41 * The MakerNotesReader is a generic class dedicated to read tags from the maker 
     42 * note sub IFD structure 
     43 * 
    3744 * 
    3845 * ======> See IfdReader.class.php to know more about an IFD structure <======== 
  • extensions/AMetaData/JpegMetaData/Readers/PentaxReader.class.php

    r4686 r4698  
    99 *   << May the Little SpaceFrog be with you ! >> 
    1010 * 
     11 * 
     12 * +-----------------------------------------------------------------------+ 
     13 * | JpegMetaData - a PHP based Jpeg Metadata manager                      | 
     14 * +-----------------------------------------------------------------------+ 
     15 * | Copyright(C) 2010  Grum - http://www.grum.fr                          | 
     16 * +-----------------------------------------------------------------------+ 
     17 * | This program is free software; you can redistribute it and/or modify  | 
     18 * | it under the terms of the GNU General Public License as published by  | 
     19 * | the Free Software Foundation                                          | 
     20 * |                                                                       | 
     21 * | This program is distributed in the hope that it will be useful, but   | 
     22 * | WITHOUT ANY WARRANTY; without even the implied warranty of            | 
     23 * | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      | 
     24 * | General Public License for more details.                              | 
     25 * |                                                                       | 
     26 * | You should have received a copy of the GNU General Public License     | 
     27 * | along with this program; if not, write to the Free Software           | 
     28 * | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, | 
     29 * | USA.                                                                  | 
     30 * +-----------------------------------------------------------------------+ 
     31 * 
     32 * 
    1133 * ----------------------------------------------------------------------------- 
    1234 * 
     35 * The PentaxReader class is the dedicated to read the specific Pentax tags 
     36 * 
     37 * ====> See MakerNotesReader.class.php to know more about the structure <====== 
     38 * 
    1339 * ----------------------------------------------------------------------------- 
    14  * Pentax reader class 
     40 * 
     41 * .. Notes .. 
     42 * 
     43 * 
     44 * The PentaxReader class is derived from the MakerNotesReader class. 
     45 * 
     46 * ======> See MakerNotesReader.class.php to know more about common methods <====== 
     47 * 
    1548 * ----------------------------------------------------------------------------- 
    1649 */ 
    1750 
     51 
     52 
    1853  require_once(JPEG_METADATA_DIR."TagDefinitions/PentaxTags.class.php"); 
    1954  require_once(JPEG_METADATA_DIR."Readers/MakerNotesReader.class.php"); 
     
    2156  class PentaxReader extends MakerNotesReader 
    2257  { 
     58    /** 
     59     * The constructor needs, like the ancestor, the datas to be parsed 
     60     * 
     61     * Some datas are offset on extra data, and this offset can be (some time) 
     62     * absolute inside the IFD, or relative. So, the offset of the IFD structure 
     63     * is needed 
     64     * 
     65     * The byte order can be different from the TIFF byte order ! 
     66     * 
     67     * The constructor need the maker signature (see the MakerNotesSignatures 
     68     * class for a list of known signatures) 
     69     * 
     70     * @param String $data 
     71     * @param ULong $offset : offset of IFD block in the jpeg file 
     72     * @param String $byteOrder 
     73     * @param String $makerSignature : 
     74     */ 
    2375    function __construct($data, $offset, $byteOrder, $makerSignature) 
    2476    { 
     
    3991    } 
    4092 
     93 
     94    /** 
     95     * initialize the definition for Pentax exif tags 
     96     */ 
    4197    protected function initializeTagDef() 
    4298    { 
     
    44100    } 
    45101 
     102    /** 
     103     * skip the IFD header 
     104     */ 
    46105    protected function skipHeader($headerSize=0) 
    47106    { 
     
    49108    } 
    50109 
     110    /** 
     111     * this function do the interpretation of specials tags 
     112     * 
     113     * the function return the interpreted value for the tag 
     114     * 
     115     * @param $tagId             : the id of the tag 
     116     * @param $values            : 'raw' value to be interpreted 
     117     * @param UByte $type        : if needed (for IFD structure) the type of data 
     118     * @param ULong $valueOffset : if needed, the offset of data in the jpeg file 
     119     * @return String or Array or DateTime or Integer or Float... 
     120     */ 
    51121    protected function processSpecialTag($tagId, $values, $type, $valuesOffset=0) 
    52122    { 
     
    172242          $returned=53190 -$values; 
    173243          break; 
     244 
     245        /* theses tags decoding is not yet implemented 
     246         * have to take a look on the algorithm in exiftool (it seems to work 
     247         * but I don't understand everything...) 
     248         */ 
     249 
    174250        case 0x0205: // "ShotInfo", 
    175251        case 0x0206: // "AEInfo", 
     
    192268        case 0x0222: // "ColorInfo", 
    193269 
    194         /* theses tags decoding is not yet implemented 
    195          * have to take a look on the algorithm in exiftool (it seems to work 
    196          * but I don't understand everything...) 
    197          */ 
    198270        case 0x0029: // "FrameNumber", 
    199271        case 0x0041: // "DigitalFilter", 
     
    207279          $returned="Not yet implemented;".ConvertData::toHexDump($tagId, ByteType::USHORT)." => ".ConvertData::toHexDump($values, $type); 
    208280          break; 
    209  
    210281      } 
    211  
    212282      return($returned); 
    213283    } 
    214  
    215284  } 
    216285 
    217  
    218286?> 
  • extensions/AMetaData/JpegMetaData/Readers/SegmentReader.class.php

    r4686 r4698  
    99 *   << May the Little SpaceFrog be with you ! >> 
    1010 * 
    11  * ----------------------------------------------------------------------------- 
     11 * 
     12 * +-----------------------------------------------------------------------+ 
     13 * | JpegMetaData - a PHP based Jpeg Metadata manager                      | 
     14 * +-----------------------------------------------------------------------+ 
     15 * | Copyright(C) 2010  Grum - http://www.grum.fr                          | 
     16 * +-----------------------------------------------------------------------+ 
     17 * | This program is free software; you can redistribute it and/or modify  | 
     18 * | it under the terms of the GNU General Public License as published by  | 
     19 * | the Free Software Foundation                                          | 
     20 * |                                                                       | 
     21 * | This program is distributed in the hope that it will be useful, but   | 
     22 * | WITHOUT ANY WARRANTY; without even the implied warranty of            | 
     23 * | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      | 
     24 * | General Public License for more details.                              | 
     25 * |                                                                       | 
     26 * | You should have received a copy of the GNU General Public License     | 
     27 * | along with this program; if not, write to the Free Software           | 
     28 * | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, | 
     29 * | USA.                                                                  | 
     30 * +-----------------------------------------------------------------------+ 
    1231 * 
    1332 * 
    1433 * ----------------------------------------------------------------------------- 
     34 * 
     35 * The SegmentReader is a generic class providing methods to manage datas 
     36 * segments 
     37 * 
     38 * ----------------------------------------------------------------------------- 
     39 * 
     40 * .. Notes .. 
     41 * 
     42 * This class is not declared as an abstract class, but it's not recommanded to 
     43 * create object with it. 
     44 * 
     45 * 
     46 * Derived classes : 
     47 *  - TiffReader        (for Tiff data block) 
     48 * 
     49 * This class provides theses public functions : 
     50 *  - getIsValid 
     51 *  - getIsLoaded 
    1552 * 
    1653 * ----------------------------------------------------------------------------- 
     
    2360    protected $isLoaded = false; 
    2461 
     62    /** 
     63     * The constructor need the segment's datas 
     64     * 
     65     * @param Data $data : a Data object 
     66     */ 
    2567    function __construct(Data $data) 
    2668    { 
     
    2971    } 
    3072 
     73    /** 
     74     * return true if the segment is valid 
     75     * 
     76     * @return Boolean 
     77     */ 
    3178    public function getIsValid() 
    3279    { 
     
    3481    } 
    3582 
     83    /** 
     84     * return true if the segment is loaded 
     85     * 
     86     * @return Boolean 
     87     */ 
    3688    public function getIsLoaded() 
    3789    { 
  • extensions/AMetaData/JpegMetaData/Readers/TiffReader.class.php

    r4686 r4698  
    99 *   << May the Little SpaceFrog be with you ! >> 
    1010 * 
    11  * ----------------------------------------------------------------------------- 
     11 * 
     12 * +-----------------------------------------------------------------------+ 
     13 * | JpegMetaData - a PHP based Jpeg Metadata manager                      | 
     14 * +-----------------------------------------------------------------------+ 
     15 * | Copyright(C) 2010  Grum - http://www.grum.fr                          | 
     16 * +-----------------------------------------------------------------------+ 
     17 * | This program is free software; you can redistribute it and/or modify  | 
     18 * | it under the terms of the GNU General Public License as published by  | 
     19 * | the Free Software Foundation                                          | 
     20 * |                                                                       | 
     21 * | This program is distributed in the hope that it will be useful, but   | 
     22 * | WITHOUT ANY WARRANTY; without even the implied warranty of            | 
     23 * | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      | 
     24 * | General Public License for more details.                              | 
     25 * |                                                                       | 
     26 * | You should have received a copy of the GNU General Public License     | 
     27 * | along with this program; if not, write to the Free Software           | 
     28 * | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, | 
     29 * | USA.                                                                  | 
     30 * +-----------------------------------------------------------------------+ 
    1231 * 
    1332 * 
    1433 * ----------------------------------------------------------------------------- 
    1534 * 
     35 * The TiffReader class is the dedicated to read a TIFF structure 
     36 * 
     37 * A Tiff structure is formatted as this : 
     38 *  - byte order            : 2 bytes, "II" or "MM", indicates the byte order 
     39 *  - header tag            : 2 bytes, UShort equals 0x002a 
     40 *  - first IFD offset      : 4 bytes, ULong 
     41 *  - IFDs                  : 
     42 * 
     43 * => See IfdReader.class.php & IfdEntryReader.class.php to know more on IFD <== 
     44 * 
     45 * ----------------------------------------------------------------------------- 
     46 * 
     47 * .. Notes .. 
     48 * 
     49 * 
     50 * The TiffReader class is derived from the SegmentReader class. 
     51 * 
     52 * ======> See SegmentReader.class.php to know more about common methods <====== 
     53 * 
     54 * 
     55 * This class provides theses public functions : 
     56 *  - getNbIFDs 
     57 *  - getIFDs 
     58 *  - getIFD 
     59 * 
    1660 * ----------------------------------------------------------------------------- 
    1761 */ 
     62 
    1863 
    1964  require_once(JPEG_METADATA_DIR."Common/ConvertData.class.php"); 
     
    2974    private $firstIFDOffset = 0; 
    3075 
     76    /** 
     77     * The constructor need the Tiff block datas (given as a Data object) and 
     78     * offset of the TIFF block inside the jpeg file 
     79     * 
     80     * @param Data $data : 
     81     * @param ULong $offsetData (optional) : 
     82     */ 
    3183    function __construct(Data $data, $offsetData=0) 
    3284    { 
     
    48100 
    49101        $header=$this->data->readUShort(); 
    50         if($header==0x2a) 
     102        if($header==0x002a) 
    51103        { 
    52104          $this->isValid=true; 
     
    62114    } 
    63115 
    64     private function readData() 
    65     { 
    66       $nextIFD = $this->firstIFDOffset; 
    67       while($nextIFD!=0) 
    68       { 
    69         $this->data->seek($nextIFD); 
    70         $IFD = new IfdReader($this->data->readASCII(), $nextIFD, $this->byteOrder); 
    71         $this->IFDs[]=$IFD; 
    72         $nextIFD = $IFD->getNextIFDOffset(); 
    73       } 
    74     } 
    75  
     116    /** 
     117     * return the number of IFDs found in the Tiff block 
     118     * 
     119     * @return Integer 
     120     */ 
    76121    public function getNbIFDs() 
    77122    { 
     
    79124    } 
    80125 
     126    /** 
     127     * return an array of IFD found in the the Tiff block 
     128     * 
     129     * @return IFD[] 
     130     */ 
    81131    public function getIFDs() 
    82132    { 
     
    84134    } 
    85135 
     136    /** 
     137     * returns a specific IFD 
     138     * 
     139     * @param Integer $num : index of the needed IFD 
     140     * @return IFD 
     141     */ 
    86142    public function getIFD($num) 
    87143    { 
     
    91147        return(null); 
    92148    } 
    93  
    94149 
    95150    public function toString() 
     
    104159    } 
    105160 
     161    /** 
     162     * The readData function read IFDs from the Tiff block, and add them into 
     163     * the IFDs array 
     164     */ 
     165    private function readData() 
     166    { 
     167      $nextIFD = $this->firstIFDOffset; 
     168      /* 
     169       * while the next IFD offset is not zero, read the IFD at the designed 
     170       * offset 
     171       * 
     172       * the next IFD offset is given at the end of the last IFD read. 
     173       */ 
     174      while($nextIFD!=0) 
     175      { 
     176        $this->data->seek($nextIFD); 
     177        $IFD = new IfdReader($this->data->readASCII(), $nextIFD, $this->byteOrder); 
     178        $this->IFDs[]=$IFD; 
     179        $nextIFD = $IFD->getNextIFDOffset(); 
     180      } 
     181    } 
    106182  } 
    107183 
  • extensions/AMetaData/JpegMetaData/Readers/XmpReader.class.php

    r4686 r4698  
    295295        $tagProperties=$this->tagDef->getTagById($name); 
    296296 
    297         $tag->setIsKnown(true); 
    298         $tag->setIsImplemented($tagProperties['implemented']); 
    299         $tag->setIsTranslatable($tagProperties['translatable']); 
     297        $tag->setKnown(true); 
     298        $tag->setImplemented($tagProperties['implemented']); 
     299        $tag->setTranslatable($tagProperties['translatable']); 
    300300 
    301301 
  • extensions/AMetaData/JpegMetaData/TagDefinitions/GpsTags.class.php

    r4686 r4698  
    1010 * 
    1111 * 
     12 * +-----------------------------------------------------------------------+ 
     13 * | JpegMetaData - a PHP based Jpeg Metadata manager                      | 
     14 * +-----------------------------------------------------------------------+ 
     15 * | Copyright(C) 2010  Grum - http://www.grum.fr                          | 
     16 * +-----------------------------------------------------------------------+ 
     17 * | This program is free software; you can redistribute it and/or modify  | 
     18 * | it under the terms of the GNU General Public License as published by  | 
     19 * | the Free Software Foundation                                          | 
     20 * |                                                                       | 
     21 * | This program is distributed in the hope that it will be useful, but   | 
     22 * | WITHOUT ANY WARRANTY; without even the implied warranty of            | 
     23 * | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      | 
     24 * | General Public License for more details.                              | 
     25 * |                                                                       | 
     26 * | You should have received a copy of the GNU General Public License     | 
     27 * | along with this program; if not, write to the Free Software           | 
     28 * | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, | 
     29 * | USA.                                                                  | 
     30 * +-----------------------------------------------------------------------+ 
     31 * 
     32 * 
    1233 * ----------------------------------------------------------------------------- 
    13  * Known IFD tags properties class 
     34 * 
     35 * The GpsTags is the definition of the Gps Exif tags 
     36 * 
    1437 * ----------------------------------------------------------------------------- 
     38 * 
     39 * .. Notes .. 
     40 * 
     41 * The GpsTags class is derived from the KnownTags class. 
     42 * 
     43 * ======> See KnownTags.class.php to know more about the tag definitions <===== 
     44 * 
    1545 */ 
    1646 
  • extensions/AMetaData/JpegMetaData/TagDefinitions/IfdTags.class.php

    r4686 r4698  
    1010 * 
    1111 * 
     12 * +-----------------------------------------------------------------------+ 
     13 * | JpegMetaData - a PHP based Jpeg Metadata manager                      | 
     14 * +-----------------------------------------------------------------------+ 
     15 * | Copyright(C) 2010  Grum - http://www.grum.fr                          | 
     16 * +-----------------------------------------------------------------------+ 
     17 * | This program is free software; you can redistribute it and/or modify  | 
     18 * | it under the terms of the GNU General Public License as published by  | 
     19 * | the Free Software Foundation                                          | 
     20 * |                                                                       | 
     21 * | This program is distributed in the hope that it will be useful, but   | 
     22 * | WITHOUT ANY WARRANTY; without even the implied warranty of            | 
     23 * | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      | 
     24 * | General Public License for more details.                              | 
     25 * |                                                                       | 
     26 * | You should have received a copy of the GNU General Public License     | 
     27 * | along with this program; if not, write to the Free Software           | 
     28 * | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, | 
     29 * | USA.                                                                  | 
     30 * +-----------------------------------------------------------------------+ 
     31 * 
     32 * 
    1233 * ----------------------------------------------------------------------------- 
    13  * Known IFD tags properties class 
     34 * 
     35 * The IfdTags is the definition of the Tiff & Exif tags 
     36 * 
    1437 * ----------------------------------------------------------------------------- 
     38 * 
     39 * .. Notes .. 
     40 * 
     41 * The IfdTags class is derived from the KnownTags class. 
     42 * 
     43 * ======> See KnownTags.class.php to know more about the tag definitions <===== 
     44 * 
    1545 */ 
    1646 
  • extensions/AMetaData/JpegMetaData/TagDefinitions/IptcTags.class.php

    r4686 r4698  
    1010 * 
    1111 * 
     12 * +-----------------------------------------------------------------------+ 
     13 * | JpegMetaData - a PHP based Jpeg Metadata manager                      | 
     14 * +-----------------------------------------------------------------------+ 
     15 * | Copyright(C) 2010  Grum - http://www.grum.fr                          | 
     16 * +-----------------------------------------------------------------------+ 
     17 * | This program is free software; you can redistribute it and/or modify  | 
     18 * | it under the terms of the GNU General Public License as published by  | 
     19 * | the Free Software Foundation                                          | 
     20 * |                                                                       | 
     21 * | This program is distributed in the hope that it will be useful, but   | 
     22 * | WITHOUT ANY WARRANTY; without even the implied warranty of            | 
     23 * | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      | 
     24 * | General Public License for more details.                              | 
     25 * |                                                                       | 
     26 * | You should have received a copy of the GNU General Public License     | 
     27 * | along with this program; if not, write to the Free Software           | 
     28 * | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, | 
     29 * | USA.                                                                  | 
     30 * +-----------------------------------------------------------------------+ 
     31 * 
     32 * 
    1233 * ----------------------------------------------------------------------------- 
    13  * Known IPTC tags properties class 
     34 * 
     35 * The IptcTags is the definition of the IPTC tags 
     36 * 
    1437 * ----------------------------------------------------------------------------- 
     38 * 
     39 * .. Notes .. 
     40 * 
     41 * The IptcTags class is derived from the KnownTags class. 
     42 * 
     43 * ======> See KnownTags.class.php to know more about the tag definitions <===== 
     44 * 
    1545 */ 
    1646 
  • extensions/AMetaData/JpegMetaData/TagDefinitions/KnownTags.class.php

    r4686 r4698  
    99 *   << May the Little SpaceFrog be with you ! >> 
    1010 * 
     11 * +-----------------------------------------------------------------------+ 
     12 * | JpegMetaData - a PHP based Jpeg Metadata manager                      | 
     13 * +-----------------------------------------------------------------------+ 
     14 * | Copyright(C) 2010  Grum - http://www.grum.fr                          | 
     15 * +-----------------------------------------------------------------------+ 
     16 * | This program is free software; you can redistribute it and/or modify  | 
     17 * | it under the terms of the GNU General Public License as published by  | 
     18 * | the Free Software Foundation                                          | 
     19 * |                                                                       | 
     20 * | This program is distributed in the hope that it will be useful, but   | 
     21 * | WITHOUT ANY WARRANTY; without even the implied warranty of            | 
     22 * | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      | 
     23 * | General Public License for more details.                              | 
     24 * |                                                                       | 
     25 * | You should have received a copy of the GNU General Public License     | 
     26 * | along with this program; if not, write to the Free Software           | 
     27 * | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, | 
     28 * | USA.                                                                  | 
     29 * +-----------------------------------------------------------------------+ 
     30 * 
     31 * 
    1132 * ----------------------------------------------------------------------------- 
    1233 * 
     34 * The KnownTags is a generic class to manage the definition of tags 
     35 * 
     36 * Tags are defined in an array $tags : 
     37 *  - key   => the Tag ID (UShort for exif & Iptc, String for Xmp) 
     38 *  - value => an array with theses properties 
     39 * 
     40 *      Common properties 
     41 *       'tagName'      => String : the official name of the tag (used for 
     42 *                         translation) 
     43 *       'tagValues'    => Array : an array to associate a label for each known 
     44 *                         values 
     45 *       'translatable' => Boolean : set to true if the value can be translated 
     46 *       'implemented'  => Boolean : set to true if the tag needs a specific 
     47 *                         interpretation and is implemented 
     48 *       'schema'       => String : schema associated with the tag 
     49 *                         exif : "tiff", "exif", "gps", "pentax", ... 
     50 *                         xmp : "dc", "exif", "photoshop", ... 
     51 *                         => not yet defined for Iptc.... 
     52 *       'tagValues.special' => used on some tags for implementation 
     53 * 
     54 *      Exif like tags 
     55 *       'combiTag'     => Integer : use on some specific tags 
     56 * 
     57 *      Xmp specific properties (==> see XmpTags.class.php for more information) 
     58 *       'iptcTag'      => if the Xmp tag exist in Iptc, the Iptc tag Id 
     59 *       'exifTag'      => if the Xmp tag exist in Exif, the Exif tag Id 
     60 *       'type'         => the type of Xmp data 
     61 * 
    1362 * ----------------------------------------------------------------------------- 
    1463 * 
     64 * .. Notes .. 
     65 * 
     66 * This class is not declared as an abstract class, but it's not recommanded to 
     67 * create object with it. 
     68 * 
     69 * Derived classes : 
     70 *  - GpsTags      (exif gps tags) 
     71 *  - IfdTag       (exif & tiff tags) 
     72 *  - IptcTag      (iptc tags) 
     73 *  - PentaxTag    (pentax exif tags) 
     74 *  - XmpTag       (xmp tags) 
     75 * 
     76 * 
     77 * This class provides theses public functions : 
     78 *  - getTags 
     79 *  - tagIdExists 
     80 *  - getTagById 
     81 *  - getTagIdByName 
     82 *  - getTagByName 
     83 *  - getLabel 
     84 * 
    1585 * ----------------------------------------------------------------------------- 
     86 * 
    1687 */ 
    1788 
     
    35106    } 
    36107 
     108    /** 
     109     * this function return the $tags array 
     110     * 
     111     * an optional parameter $filter can be given. 
     112     * its an array with the keys : 
     113     *  'implemented' => Integer = KNOWN_TAGS_ALL, KNOWN_TAGS_IMPLEMENTED, KNOWN_TAGS_NOT_IMPLEMENTED 
     114     *                   filter tags with the property 'implemented' and 'known' 
     115     *  'schema'      => String = name of the schema 
     116     *                   filter tags with the schema property 
     117     * 
     118     * @param Array $filter (optional) 
     119     * @return Array : an array of tags properties (see this file header to know 
     120     *                 more about the tag properties) 
     121     */ 
    37122    public function getTags($filter = Array('implemented' => KNOWN_TAGS_ALL, 'schema' => NULL)) 
    38123    { 
     
    64149    } 
    65150 
     151    /** 
     152     * this function returns true if the given ID exists 
     153     * 
     154     * @return Boolean 
     155     */ 
    66156    public function tagIdExists($id) 
    67157    { 
     
    69159    } 
    70160 
    71  
     161    /** 
     162     * returns a tag, searched by its ID 
     163     * return false if the tag is not found 
     164     * 
     165     * @return Array : see this file header to know more about the tag properties 
     166     */ 
    72167    public function getTagById($id) 
    73168    { 
     
    79174    } 
    80175 
     176    /** 
     177     * returns the tag ID, searched by its name property 
     178     * return false if the tag is not found 
     179     * 
     180     * @return String or UShort 
     181     */ 
    81182    public function getTagIdByName($name) 
    82183    { 
     
    89190    } 
    90191 
     192    /** 
     193     * returns a Tag, searched by its name property 
     194     * return false if the tag is not found 
     195     * 
     196     * @return Array : see this file header to know more about the tag properties 
     197     */ 
    91198    public function getTagByName($name) 
    92199    { 
    93200      $index=$this->getTagIdByName($name); 
    94       if(index!==false) 
     201      if($index!==false) 
    95202        return($this->tags[$index]); 
    96203      return(false); 
    97204    } 
    98205 
     206    /** 
     207     * return the label associated with the tag defininition 
     208     * (something like "Exif & Tiff tags" or "Pentax specific tags") 
     209     * 
     210     * @return String 
     211     */ 
    99212    public function getLabel() 
    100213    { 
  • extensions/AMetaData/JpegMetaData/TagDefinitions/PentaxTags.class.php

    r4686 r4698  
    99 *   << May the Little SpaceFrog be with you ! >> 
    1010 * 
    11  * ----------------------------------------------------------------------------- 
    1211 * 
    13  * Pentax values from 
    14  * - ExifTool / Copyright - Phil Harvey <phil at owl.phy.queensu.ca> 
    15  * - Exiv2    / Copyright - Andreas Huggel <ahuggel at gmx.net> 
    16  * 
     12 * +-----------------------------------------------------------------------+ 
     13 * | JpegMetaData - a PHP based Jpeg Metadata manager                      | 
     14 * +-----------------------------------------------------------------------+ 
     15 * | Copyright(C) 2010  Grum - http://www.grum.fr                          | 
     16 * +-----------------------------------------------------------------------+ 
     17 * | This program is free software; you can redistribute it and/or modify  | 
     18 * | it under the terms of the GNU General Public License as published by  | 
     19 * | the Free Software Foundation                                          | 
     20 * |                                                                       | 
     21 * | This program is distributed in the hope that it will be useful, but   | 
     22 * | WITHOUT ANY WARRANTY; without even the implied warranty of            | 
     23 * | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      | 
     24 * | General Public License for more details.                              | 
     25 * |                                                                       | 
     26 * | You should have received a copy of the GNU General Public License     | 
     27 * | along with this program; if not, write to the Free Software           | 
     28 * | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, | 
     29 * | USA.                                                                  | 
     30 * +-----------------------------------------------------------------------+ 
    1731 * 
    1832 * 
    1933 * ----------------------------------------------------------------------------- 
    20  * Pentax tags definition & Pentax reader class 
     34 * 
     35 * The PentaxTags is the definition of the specific Pentax Exif tags 
     36 * 
    2137 * ----------------------------------------------------------------------------- 
     38 * 
     39 * .. Notes .. 
     40 * 
     41 * The PentaxTags class is derived from the KnownTags class. 
     42 * 
     43 * ======> See KnownTags.class.php to know more about the tag definitions <===== 
     44 * 
     45 * 
     46 * Pentax values from 
     47 *  - Exiftool by Phil Harvey    => http://www.sno.phy.queensu.ca/~phil/exiftool/ 
     48 *                                  http://owl.phy.queensu.ca/~phil/exiftool/TagNames 
     49 *  - Exiv2 by Andreas Huggel    => http://www.exiv2.org/ 
     50 * 
    2251 */ 
    2352 
     
    3867      0x0001 => Array( 
    3968        'tagName'     => "ShootingMode", 
    40         'group' => Array("Pentax"), 
     69        'schema'      => "Pentax", 
    4170        'translatable'=> true, 
    4271        'combiTag'    => 0, 
     
    5281      0x0005 => Array( 
    5382        'tagName'     => "CameraModel", 
    54         'group' => Array("Pentax"), 
     83        'schema'      => "Pentax", 
    5584        'translatable'=> false, 
    5685        'combiTag'    => 0, 
     
    148177      0x0008 => Array( 
    149178        'tagName'     => "Quality", 
    150         'group' => Array("Pentax"), 
     179        'schema'      => "Pentax", 
    151180        'translatable'=> true, 
    152181        'combiTag'    => 0, 
     
    166195      0x0009 => Array( 
    167196        'tagName'     => "Size", 
    168         'group' => Array("Pentax"), 
     197        'schema'      => "Pentax", 
    169198        'translatable'=> true, 
    170199        'combiTag'    => 0, 
     
    196225      0x000b => Array( 
    197226        'tagName'     => "PictureMode", 
    198         'group' => Array("Pentax"), 
     227        'schema'      => "Pentax", 
    199228        'translatable'=> true, 
    200229        'combiTag'    => 0, 
     
    244273      0x000c => Array( 
    245274        'tagName'     => "Flash", 
    246         'group' => Array("Pentax"), 
     275        'schema'      => "Pentax", 
    247276        'translatable'=> true, 
    248277        'combiTag'    => 0, 
     
    283312      0x000d => Array( 
    284313        'tagName'     => "Focus", 
    285         'group' => Array("Pentax"), 
     314        'schema'      => "Pentax", 
    286315        'translatable'=> true, 
    287316        'combiTag'    => 0, 
     
    303332      0x000e => Array( 
    304333        'tagName'     => "AFPoint", 
    305         'group' => Array("Pentax"), 
     334        'schema'      => "Pentax", 
    306335        'translatable'=> true, 
    307336        'combiTag'    => 0, 
     
    329358      0x000f => Array( 
    330359        'tagName'     => "AFPointsInFocus", 
    331         'group' => Array("Pentax"), 
     360        'schema'      => "Pentax", 
    332361        'translatable'=> true, 
    333362        'combiTag'    => 0, 
     
    351380      0x0014 => Array( 
    352381        'tagName'     => "ISO", 
    353         'group' => Array("Pentax"), 
     382        'schema'      => "Pentax", 
    354383        'translatable'=> false, 
    355384        'combiTag'    => 0, 
     
    405434      0x0017 => Array( 
    406435        'tagName'     => "MeteringMode", 
    407         'group' => Array("Pentax"), 
     436        'schema'      => "Pentax", 
    408437        'translatable'=> true, 
    409438        'combiTag'    => 0, 
     
    419448      0x0019 => Array( 
    420449        'tagName'     => "WhiteBallance", 
    421         'group' => Array("Pentax"), 
     450        'schema'      => "Pentax", 
    422451        'translatable'=> true, 
    423452        'combiTag'    => 0, 
     
    444473      0x001a => Array( 
    445474        'tagName'     => "WhiteBallanceMode", 
    446         'group' => Array("Pentax"), 
     475        'schema'      => "Pentax", 
    447476        'translatable'=> true, 
    448477        'combiTag'    => 0, 
     
    465494      0x001f => Array( 
    466495        'tagName'     => "Saturation", 
    467         'group' => Array("Pentax"), 
     496        'schema'      => "Pentax", 
    468497        'translatable'=> true, 
    469498        'combiTag'    => 0, 
     
    484513      0x0020 => Array( 
    485514        'tagName'     => "Contrast", 
    486         'group' => Array("Pentax"), 
     515        'schema'      => "Pentax", 
    487516        'translatable'=> true, 
    488517        'combiTag'    => 0, 
     
    502531      0x0021 => Array( 
    503532        'tagName'     => "Sharpness", 
    504         'group' => Array("Pentax"), 
     533        'schema'      => "Pentax", 
    505534        'translatable'=> true, 
    506535        'combiTag'    => 0, 
     
    520549      0x0022 => Array( 
    521550        'tagName'     => "WorldTimeLocation", 
    522         'group' => Array("Pentax"), 
     551        'schema'      => "Pentax", 
    523552        'translatable'=> true, 
    524553        'combiTag'    => 0, 
     
    533562      0x0023 => Array( 
    534563        'tagName'     => "HomeCityName", 
    535         'group' => Array("Pentax"), 
     564        'schema'      => "Pentax", 
    536565        'translatable'=> true, 
    537566        'combiTag'    => 0, 
     
    616645      0x0024 => Array( 
    617646        'tagName'     => "DestinationCityName", 
    618         'group' => Array("Pentax"), 
     647        'schema'      => "Pentax", 
    619648        'translatable'=> true, 
    620649        'combiTag'    => 0, 
     
    700729      0x0032 => Array( 
    701730        'tagName'     => "ImageProcessing", 
    702         'group' => Array("Pentax"), 
     731        'schema'      => "Pentax", 
    703732        'translatable'=> true, 
    704733        'combiTag'    => 4, 
     
    717746      0x0033 => Array( 
    718747        'tagName'     => "PictureMode", 
    719         'group' => Array("Pentax"), 
     748        'schema'      => "Pentax", 
    720749        'translatable'=> true, 
    721750        'combiTag'    => 3, 
     
    793822      0x0034 => Array( 
    794823        'tagName'     => "DriveMode", 
    795         'group' => Array("Pentax"), 
     824        'schema'      => "Pentax", 
    796825        'translatable'=> true, 
    797826        'combiTag'    => 4, 
     
    817846      0x0037 => Array( 
    818847        'tagName'     => "ColorSpace", 
    819         'group' => Array("Pentax"), 
     848        'schema'      => "Pentax", 
    820849        'translatable'=> false, 
    821850        'combiTag'    => 0, 
     
    830859      0x003f => Array( 
    831860        'tagName'     => "LensType", 
    832         'group' => Array("Pentax"), 
     861        'schema'      => "Pentax", 
    833862        'translatable'=> true, 
    834863        'combiTag'    => 2, 
     
    9931022      0x004f => Array( 
    9941023        'tagName'     => "ImageTone", 
    995         'group' => Array("Pentax"), 
     1024        'schema'      => "Pentax", 
    9961025        'translatable'=> true, 
    9971026        'combiTag'    => 0, 
     
    10111040      0x0069 => Array( 
    10121041        'tagName'     => "DynamicRangeExpansion", 
    1013         'group' => Array("Pentax"), 
     1042        'schema'      => "Pentax", 
    10141043        'translatable'=> true, 
    10151044        'combiTag'    => 4, 
     
    10251054      0x0071 => Array( 
    10261055        'tagName'     => "HighISONoiseReduction", 
    1027         'group' => Array("Pentax"), 
     1056        'schema'      => "Pentax", 
    10281057        'translatable'=> true, 
    10291058        'combiTag'    => 0, 
     
    10451074      0x0000 => Array( 
    10461075        'tagName'     => "Version", 
    1047         'group' => Array("Pentax"), 
     1076        'schema'      => "Pentax", 
    10481077        'translatable'=> false, 
    10491078        'combiTag'    => 0, 
     
    10541083      0x0002 => Array( 
    10551084        'tagName'     => "PreviewResolution", 
    1056         'group' => Array("Pentax"), 
     1085        'schema'      => "Pentax", 
    10571086        'translatable'=> false, 
    10581087        'combiTag'    => 0, 
     
    10631092      0x0003 => Array( 
    10641093        'tagName'     => "PreviewLength", 
    1065         'group' => Array("Pentax"), 
     1094        'schema'      => "Pentax", 
    10661095        'translatable'=> false, 
    10671096        'combiTag'    => 0, 
     
    10721101      0x0004 => Array( 
    10731102        'tagName'     => "PreviewOffset", 
    1074         'group' => Array("Pentax"), 
     1103        'schema'      => "Pentax", 
    10751104        'translatable'=> false, 
    10761105        'combiTag'    => 0, 
     
    10811110      0x0006 => Array( 
    10821111        'tagName'     => "Date", 
    1083         'group' => Array("Pentax"), 
     1112        'schema'      => "Pentax", 
    10841113        'translatable'=> false, 
    10851114        'combiTag'    => 0, 
     
    10901119      0x0007 => Array( 
    10911120        'tagName'     => "Time", 
    1092         'group' => Array("Pentax"), 
     1121        'schema'      => "Pentax", 
    10931122        'translatable'=> false, 
    10941123        'combiTag'    => 0, 
     
    10991128      0x0010 => Array( 
    11001129        'tagName'     => "FocusPosition", 
    1101         'group' => Array("Pentax"), 
     1130        'schema'      => "Pentax", 
    11021131        'translatable'=> false, 
    11031132        'combiTag'    => 0, 
     
    11081137      0x0012 => Array( 
    11091138        'tagName'     => "ExposureTime", 
    1110         'group' => Array("Pentax"), 
     1139        'schema'      => "Pentax", 
    11111140        'translatable'=> false, 
    11121141        'combiTag'    => 0, 
     
    11171146      0x0013 => Array( 
    11181147        'tagName'     => "FNumber", 
    1119         'group' => Array("Pentax"), 
     1148        'schema'      => "Pentax", 
    11201149        'translatable'=> false, 
    11211150        'combiTag'    => 0, 
     
    11261155      0x0015 => Array( 
    11271156        'tagName'     => "LightReading", 
    1128         'group' => Array("Pentax"), 
     1157        'schema'      => "Pentax", 
    11291158        'translatable'=> false, 
    11301159        'combiTag'    => 0, 
     
    11361165      0x0016 => Array( 
    11371166        'tagName'     => "ExposureCompensation", 
    1138         'group' => Array("Pentax"), 
     1167        'schema'      => "Pentax", 
    11391168        'translatable'=> false, 
    11401169        'combiTag'    => 0, 
     
    11451174      0x0018 => Array( 
    11461175        'tagName'     => "AutoBracketing", 
    1147         'group' => Array("Pentax"), 
     1176        'schema'      => "Pentax", 
    11481177        'translatable'=> true, 
    11491178        'combiTag'    => 0, 
     
    11541183      0x001b => Array( 
    11551184        'tagName'     => "BlueBalance", 
    1156         'group' => Array("Pentax"), 
     1185        'schema'      => "Pentax", 
    11571186        'translatable'=> false, 
    11581187        'combiTag'    => 0, 
     
    11631192      0x001c => Array( 
    11641193        'tagName'     => "RedBalance", 
    1165         'group' => Array("Pentax"), 
     1194        'schema'      => "Pentax", 
    11661195        'translatable'=> false, 
    11671196        'combiTag'    => 0, 
     
    11721201      0x001d => Array( 
    11731202        'tagName'     => "FocalLength", 
    1174         'group' => Array("Pentax"), 
     1203        'schema'      => "Pentax", 
    11751204        'translatable'=> false, 
    11761205        'combiTag'    => 0, 
     
    11811210      0x001e => Array( 
    11821211        'tagName'     => "DigitalZoom", 
    1183         'group' => Array("Pentax"), 
     1212        'schema'      => "Pentax", 
    11841213        'translatable'=> false, 
    11851214        'combiTag'    => 0, 
     
    11911220      0x0025 => Array( 
    11921221        'tagName'     => "HometownDST", 
    1193         'group' => Array("Pentax"), 
     1222        'schema'      => "Pentax", 
    11941223        'translatable'=> false, 
    11951224        'combiTag'    => 0, 
     
    12001229      0x0026 => Array( 
    12011230        'tagName'     => "DestinationDST", 
    1202         'group' => Array("Pentax"), 
     1231        'schema'      => "Pentax", 
    12031232        'translatable'=> false, 
    12041233        'combiTag'    => 0, 
     
    12091238      0x0027 => Array( 
    12101239        'tagName'     => "DSPFirmwareVersion", 
    1211         'group' => Array("Pentax"), 
     1240        'schema'      => "Pentax", 
    12121241        'translatable'=> false, 
    12131242        'combiTag'    => 0, 
     
    12181247      0x0028 => Array( 
    12191248        'tagName'     => "CPUFirmwareVersion", 
    1220         'group' => Array("Pentax"), 
     1249        'schema'      => "Pentax", 
    12211250        'translatable'=> false, 
    12221251        'combiTag'    => 0, 
     
    12271256      0x0029 => Array( 
    12281257        'tagName'     => "FrameNumber", 
    1229         'group' => Array("Pentax"), 
     1258        'schema'      => "Pentax", 
    12301259        'translatable'=> false, 
    12311260        'combiTag'    => 0, 
     
    12361265      0x002d => Array( 
    12371266        'tagName'     => "EffectiveLV", 
    1238         'group' => Array("Pentax"), 
     1267        'schema'      => "Pentax", 
    12391268        'translatable'=> false, 
    12401269        'combiTag'    => 0, 
     
    12451274      0x0038 => Array( 
    12461275        'tagName'     => "ImageAreaOffset", 
    1247         'group' => Array("Pentax"), 
     1276        'schema'      => "Pentax", 
    12481277        'translatable'=> false, 
    12491278        'combiTag'    => 0, 
     
    12541283      0x0039 => Array( 
    12551284        'tagName'     => "RawImageSize", 
    1256         'group' => Array("Pentax"), 
     1285        'schema'      => "Pentax", 
    12571286        'translatable'=> false, 
    12581287        'combiTag'    => 0, 
     
    12631292      0x003c => Array( 
    12641293        'tagName'     => "AFPointsInFocus", 
    1265         'group' => Array("Pentax"), 
     1294        'schema'      => "Pentax", 
    12661295        'translatable'=> false, 
    12671296        'combiTag'    => 0, 
     
    12721301      0x003e => Array( 
    12731302        'tagName'     => "PreviewImageBorders", 
    1274         'group' => Array("Pentax"), 
     1303        'schema'      => "Pentax", 
    12751304        'translatable'=> false, 
    12761305        'combiTag'    => 0, 
     
    12811310      0x0040 => Array( 
    12821311        'tagName'     => "SensitivityAdjust", 
    1283         'group' => Array("Pentax"), 
     1312        'schema'      => "Pentax", 
    12841313        'translatable'=> false, 
    12851314        'combiTag'    => 0, 
     
    12901319      0x0041 => Array( 
    12911320        'tagName'     => "DigitalFilter", 
    1292         'group' => Array("Pentax"), 
     1321        'schema'      => "Pentax", 
    12931322        'translatable'=> false, 
    12941323        'combiTag'    => 0, 
     
    12991328      0x0047 => Array( 
    13001329        'tagName'     => "Temperature", 
    1301         'group' => Array("Pentax"), 
     1330        'schema'      => "Pentax", 
    13021331        'translatable'=> false, 
    13031332        'combiTag'    => 0, 
     
    13081337      0x0048 => Array( 
    13091338        'tagName'     => "AELock", 
    1310         'group' => Array("Pentax"), 
     1339        'schema'      => "Pentax", 
    13111340        'translatable'=> true, 
    13121341        'combiTag'    => 0, 
     
    13171346      0x0049 => Array( 
    13181347        'tagName'     => "NoiseReduction", 
    1319         'group' => Array("Pentax"), 
     1348        'schema'      => "Pentax", 
    13201349        'translatable'=> true, 
    13211350        'combiTag'    => 0, 
     
    13261355      0x004d => Array( 
    13271356        'tagName'     => "FlashExposureCompensation", 
    1328         'group' => Array("Pentax"), 
     1357        'schema'      => "Pentax", 
    13291358        'translatable'=> false, 
    13301359        'combiTag'    => 0, 
     
    13351364      0x0050 => Array( 
    13361365        'tagName'     => "ColorTemperature", 
    1337         'group' => Array("Pentax"), 
     1366        'schema'      => "Pentax", 
    13381367        'translatable'=> false, 
    13391368        'combiTag'    => 0, 
     
    13441373      0x005c => Array( 
    13451374        'tagName'     => "ShakeReduction", 
    1346         'group' => Array("Pentax"), 
     1375        'schema'      => "Pentax", 
    13471376        'translatable'=> false, 
    13481377        'combiTag'    => 0, 
     
    13531382      0x005d => Array( 
    13541383        'tagName'     => "ShutterCount", 
    1355         'group' => Array("Pentax"), 
     1384        'schema'      => "Pentax", 
    13561385        'translatable'=> false, 
    13571386        'combiTag'    => 0, 
     
    13621391      0x0072 => Array( 
    13631392        'tagName'     => "AFAdjustment", 
    1364         'group' => Array("Pentax"), 
     1393        'schema'      => "Pentax", 
    13651394        'translatable'=> false, 
    13661395        'combiTag'    => 0, 
     
    13721401      0x0200 => Array( 
    13731402        'tagName'     => "BlackPoint", 
    1374         'group' => Array("Pentax"), 
     1403        'schema'      => "Pentax", 
    13751404        'translatable'=> false, 
    13761405        'combiTag'    => 0, 
     
    13811410      0x0201 => Array( 
    13821411        'tagName'     => "WhitePoint", 
    1383         'group' => Array("Pentax"), 
     1412        'schema'      => "Pentax", 
    13841413        'translatable'=> false, 
    13851414        'combiTag'    => 0, 
     
    13901419      0x0203 => Array( 
    13911420        'tagName'     => "ColorMatrixA", 
    1392         'group' => Array("Pentax"), 
     1421        'schema'      => "Pentax", 
    13931422        'translatable'=> false, 
    13941423        'combiTag'    => 0, 
     
    13991428      0x0204 => Array( 
    14001429        'tagName'     => "ColorMatrixB", 
    1401         'group' => Array("Pentax"), 
     1430        'schema'      => "Pentax", 
    14021431        'translatable'=> false, 
    14031432        'combiTag'    => 0, 
     
    14081437      0x0205 => Array( 
    14091438        'tagName'     => "ShotInfo", 
    1410         'group' => Array("Pentax"), 
     1439        'schema'      => "Pentax", 
    14111440        'translatable'=> false, 
    14121441        'combiTag'    => 0, 
     
    14171446      0x0206 => Array( 
    14181447        'tagName'     => "AEInfo", 
    1419         'group' => Array("Pentax"), 
     1448        'schema'      => "Pentax", 
    14201449        'translatable'=> false, 
    14211450        'combiTag'    => 0, 
     
    14261455      0x0207 => Array( 
    14271456        'tagName'     => "LensInfo", 
    1428         'group' => Array("Pentax"), 
     1457        'schema'      => "Pentax", 
    14291458        'translatable'=> false, 
    14301459        'combiTag'    => 0, 
     
    14351464      0x0208 => Array( 
    14361465        'tagName'     => "FlashInfo", 
    1437         'group' => Array("Pentax"), 
     1466        'schema'      => "Pentax", 
    14381467        'translatable'=> false, 
    14391468        'combiTag'    => 0, 
     
    14441473      0x0209 => Array( 
    14451474        'tagName'     => "AEMeteringSegments", 
    1446         'group' => Array("Pentax"), 
     1475        'schema'      => "Pentax", 
    14471476        'translatable'=> false, 
    14481477        'combiTag'    => 0, 
     
    14531482      0x020a => Array( 
    14541483        'tagName'     => "FlashADump", 
    1455         'group' => Array("Pentax"), 
     1484        'schema'      => "Pentax", 
    14561485        'translatable'=> false, 
    14571486        'combiTag'    => 0, 
     
    14621491      0x020b => Array( 
    14631492        'tagName'     => "FlashBDump", 
    1464         'group' => Array("Pentax"), 
     1493        'schema'      => "Pentax", 
    14651494        'translatable'=> false, 
    14661495        'combiTag'    => 0, 
     
    14711500      0x020d => Array( 
    14721501        'tagName'     => "WB_RGGBLevelsDaylight", 
    1473         'group' => Array("Pentax"), 
     1502        'schema'      => "Pentax", 
    14741503        'translatable'=> false, 
    14751504        'combiTag'    => 0, 
     
    14801509      0x020e => Array( 
    14811510        'tagName'     => "WB_RGGBLevelsShade", 
    1482         'group' => Array("Pentax"), 
     1511        'schema'      => "Pentax", 
    14831512        'translatable'=> false, 
    14841513        'combiTag'    => 0, 
     
    14891518      0x020f => Array( 
    14901519        'tagName'     => "WB_RGGBLevelsCloudy", 
    1491         'group' => Array("Pentax"), 
     1520        'schema'      => "Pentax", 
    14921521        'translatable'=> false, 
    14931522        'combiTag'    => 0, 
     
    14981527      0x0210 => Array( 
    14991528        'tagName'     => "WB_RGGBLevelsTungsten", 
    1500         'group' => Array("Pentax"), 
     1529        'schema'      => "Pentax", 
    15011530        'translatable'=> false, 
    15021531        'combiTag'    => 0, 
     
    15071536      0x0211 => Array( 
    15081537        'tagName'     => "WB_RGGBLevelsFluorescentD", 
    1509         'group' => Array("Pentax"), 
     1538        'schema'      => "Pentax", 
    15101539        'translatable'=> false, 
    15111540        'combiTag'    => 0, 
     
    15161545      0x0212 => Array( 
    15171546        'tagName'     => "WB_RGGBLevelsFluorescentN", 
    1518         'group' => Array("Pentax"), 
     1547        'schema'      => "Pentax", 
    15191548        'translatable'=> false, 
    15201549        'combiTag'    => 0, 
     
    15251554      0x0213 => Array( 
    15261555        'tagName'     => "WB_RGGBLevelsFluorescentW", 
    1527         'group' => Array("Pentax"), 
     1556        'schema'      => "Pentax", 
    15281557        'translatable'=> false, 
    15291558        'combiTag'    => 0, 
     
    15341563      0x0214 => Array( 
    15351564        'tagName'     => "WB_RGGBLevelsFlash", 
    1536         'group' => Array("Pentax"), 
     1565        'schema'      => "Pentax", 
    15371566        'translatable'=> false, 
    15381567        'combiTag'    => 0, 
     
    15431572      0x0215 => Array( 
    15441573        'tagName'     => "CameraInfo", 
    1545         'group' => Array("Pentax"), 
     1574        'schema'      => "Pentax", 
    15461575        'translatable'=> false, 
    15471576        'combiTag'    => 0, 
     
    15521581      0x0216 => Array( 
    15531582        'tagName'     => "BatteryInfo", 
    1554         'group' => Array("Pentax"), 
     1583        'schema'      => "Pentax", 
    15551584        'translatable'=> false, 
    15561585        'combiTag'    => 0, 
     
    15611590      0x021b => Array( 
    15621591        'tagName'     => "SaturationInfo", 
    1563         'group' => Array("Pentax"), 
     1592        'schema'      => "Pentax", 
    15641593        'translatable'=> false, 
    15651594        'combiTag'    => 0, 
     
    15701599      0x021f => Array( 
    15711600        'tagName'     => "AFInfo", 
    1572         'group' => Array("Pentax"), 
     1601        'schema'      => "Pentax", 
    15731602        'translatable'=> false, 
    15741603        'combiTag'    => 0, 
     
    15791608      0x0220 => Array( 
    15801609        'tagName'     => "HuffmanTable", 
    1581         'group' => Array("Pentax"), 
     1610        'schema'      => "Pentax", 
    15821611        'translatable'=> false, 
    15831612        'combiTag'    => 0, 
     
    15881617      0x0222 => Array( 
    15891618        'tagName'     => "ColorInfo", 
    1590         'group' => Array("Pentax"), 
     1619        'schema'      => "Pentax", 
    15911620        'translatable'=> false, 
    15921621        'combiTag'    => 0, 
     
    15971626      0x0224 => Array( 
    15981627        'tagName'     => "EVStepInfo", 
    1599         'group' => Array("Pentax"), 
     1628        'schema'      => "Pentax", 
    16001629        'translatable'=> false, 
    16011630        'combiTag'    => 0, 
     
    16061635      0x0229 => Array( 
    16071636        'tagName'     => "SerialNumber", 
    1608         'group' => Array("Pentax"), 
     1637        'schema'      => "Pentax", 
    16091638        'translatable'=> false, 
    16101639        'combiTag'    => 0, 
     
    16151644      0x0230 => Array( 
    16161645        'tagName'     => "FirmwareVersion", 
    1617         'group' => Array("Pentax"), 
     1646        'schema'      => "Pentax", 
    16181647        'translatable'=> false, 
    16191648        'combiTag'    => 0, 
     
    16241653      0x03fe => Array( 
    16251654        'tagName'     => "DataDump", 
    1626         'group' => Array("Pentax"), 
     1655        'schema'      => "Pentax", 
    16271656        'translatable'=> false, 
    16281657        'combiTag'    => 0, 
     
    16331662      0x03ff => Array( 
    16341663        'tagName'     => "UnknownInfo", 
    1635         'group' => Array("Pentax"), 
     1664        'schema'      => "Pentax", 
    16361665        'translatable'=> false, 
    16371666        'combiTag'    => 0, 
     
    16421671      0x0402 => Array( 
    16431672        'tagName'     => "ToneCurve", 
    1644         'group' => Array("Pentax"), 
     1673        'schema'      => "Pentax", 
    16451674        'translatable'=> false, 
    16461675        'combiTag'    => 0, 
     
    16511680      0x0403 => Array( 
    16521681        'tagName'     => "ToneCurves", 
    1653         'group' => Array("Pentax"), 
     1682        'schema'      => "Pentax", 
    16541683        'translatable'=> false, 
    16551684        'combiTag'    => 0, 
     
    16601689      0x0e00 => Array( 
    16611690        'tagName'     => "PrintIM", 
    1662         'group' => Array("Pentax"), 
     1691        'schema'      => "Pentax", 
    16631692        'translatable'=> false, 
    16641693        'combiTag'    => 0, 
  • extensions/AMetaData/JpegMetaData/TagDefinitions/XmpTags.class.php

    r4686 r4698  
    1010 * 
    1111 * 
     12 * +-----------------------------------------------------------------------+ 
     13 * | JpegMetaData - a PHP based Jpeg Metadata manager                      | 
     14 * +-----------------------------------------------------------------------+ 
     15 * | Copyright(C) 2010  Grum - http://www.grum.fr                          | 
     16 * +-----------------------------------------------------------------------+ 
     17 * | This program is free software; you can redistribute it and/or modify  | 
     18 * | it under the terms of the GNU General Public License as published by  | 
     19 * | the Free Software Foundation                                          | 
     20 * |                                                                       | 
     21 * | This program is distributed in the hope that it will be useful, but   | 
     22 * | WITHOUT ANY WARRANTY; without even the implied warranty of            | 
     23 * | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      | 
     24 * | General Public License for more details.                              | 
     25 * |                                                                       | 
     26 * | You should have received a copy of the GNU General Public License     | 
     27 * | along with this program; if not, write to the Free Software           | 
     28 * | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, | 
     29 * | USA.                                                                  | 
     30 * +-----------------------------------------------------------------------+ 
     31 * 
     32 * 
    1233 * ----------------------------------------------------------------------------- 
    13  * Known Xmp tags properties class 
     34 * 
     35 * The XmpTags is the definition of the XMP tags 
     36 * 
    1437 * ----------------------------------------------------------------------------- 
    1538 */ 
     
    17901813        'schema'       => "Iptc4xmpCore", 
    17911814      ), 
    1792  
    1793  
    17941815    ); 
    17951816 
    1796  
    1797  
     1817    /** 
     1818     * XmpTags needs a specific constructor, allowing to extract exif & iptc 
     1819     * properties for some tags 
     1820     * 
     1821     */ 
    17981822    function __construct() 
    17991823    { 
  • extensions/AMetaData/JpegMetaData/test/index.php

    r4686 r4698  
    11<?php 
     2/* 
     3 * --:: JPEG MetaDatas ::------------------------------------------------------- 
     4 * 
     5 *  Author    : Grum 
     6 *   email    : grum at piwigo.org 
     7 *   website  : http://photos.grum.fr 
     8 * 
     9 *   << May the Little SpaceFrog be with you ! >> 
     10 * 
     11 * 
     12 * +-----------------------------------------------------------------------+ 
     13 * | JpegMetaData - a PHP based Jpeg Metadata manager                      | 
     14 * +-----------------------------------------------------------------------+ 
     15 * | Copyright(C) 2010  Grum - http://www.grum.fr                          | 
     16 * +-----------------------------------------------------------------------+ 
     17 * | This program is free software; you can redistribute it and/or modify  | 
     18 * | it under the terms of the GNU General Public License as published by  | 
     19 * | the Free Software Foundation                                          | 
     20 * |                                                                       | 
     21 * | This program is distributed in the hope that it will be useful, but   | 
     22 * | WITHOUT ANY WARRANTY; without even the implied warranty of            | 
     23 * | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      | 
     24 * | General Public License for more details.                              | 
     25 * |                                                                       | 
     26 * | You should have received a copy of the GNU General Public License     | 
     27 * | along with this program; if not, write to the Free Software           | 
     28 * | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, | 
     29 * | USA.                                                                  | 
     30 * +-----------------------------------------------------------------------+ 
     31 * 
     32 * 
     33 * ----------------------------------------------------------------------------- 
     34 * 
     35 * This file is used to test the capabilities of the JpegMetaData classes 
     36 * 
     37 * ----------------------------------------------------------------------------- 
     38 * 
     39 * 
     40 * ----------------------------------------------------------------------------- 
     41 */ 
     42 
    243 ini_set('error_reporting', E_ALL | E_STRICT); 
    344 ini_set('display_errors', true); 
     
    1354  require_once(JPEG_METADATA_DIR."TagDefinitions/XmpTags.class.php"); 
    1455 
    15 echo " 
    16 <html> 
    17 <header> 
    18 <meta http-equiv='Content-Type' content='text/html; charset=utf-8' /> 
    19 </header> 
    20 <body> 
    21 -- Tests --<br> 
    22 "; 
    23  
    24 echo "<hr>-- Images --<br>"; 
    25  
    26 $d = scandir(dirname(__FILE__)); 
    27  
    28 foreach($d as $key => $file) 
    29 { 
    30   if(preg_match("/.*\.(jpg|jpeg)/i",$file)) 
    31     echo "[<a href='?file=".$file."'>$file</a>]&nbsp; "; 
    32 } 
    33  
    34  
    35 echo "<hr>-- Resultat --<br>"; 
    36  
    37  
    38 function dump_xml($xml) 
    39 { 
    40   $color=Array( 
    41    0 => "000000", 
    42    1 => "ff0000", 
    43    2 => "0000ff", 
    44    3 => "008000", 
    45    4 => "800000", 
    46    5 => "000080", 
    47    6 => "008080", 
    48    7 => "808000", 
    49    8 => "800080", 
    50    9 => "808080"); 
    51  
    52   $parser = xml_parser_create(); 
    53   xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0); 
    54   xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1); 
    55   xml_parse_into_struct($parser, $xml, $values, $tags); 
    56   xml_parser_free($parser); 
    57  
    58   foreach($values as $key => $val) 
    59   { 
    60     switch($val['type']) 
    61     { 
    62       case "open": 
    63         echo "<span style='color:#".$color[$val['level']]."'>(".$val['level'].")".str_repeat("&nbsp;", 3*$val['level'])."".$val['tag']."</span>"; 
    64         if(array_key_exists("attributes", $val)) 
    65           foreach($val['attributes'] as $key2 => $val2) 
     56 
     57  /* 
     58   * functions 
     59   * 
     60   */ 
     61 
     62  function dump_xml($xml) 
     63  { 
     64    $returned=""; 
     65 
     66    $color=Array( 
     67     0 => "000000", 
     68     1 => "ff0000", 
     69     2 => "0000ff", 
     70     3 => "008000", 
     71     4 => "800000", 
     72     5 => "000080", 
     73     6 => "008080", 
     74     7 => "808000", 
     75     8 => "800080", 
     76     9 => "808080"); 
     77 
     78    $parser = xml_parser_create(); 
     79    xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0); 
     80    xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1); 
     81    xml_parse_into_struct($parser, $xml, $values, $tags); 
     82    xml_parser_free($parser); 
     83 
     84    foreach($values as $key => $val) 
     85    { 
     86      switch($val['type']) 
     87      { 
     88        case "open": 
     89          $returned.="<span style='color:#".$color[$val['level']]."'>(".$val['level'].")".str_repeat("&nbsp;", 3*$val['level'])."".$val['tag']."</span>"; 
     90          if(array_key_exists("attributes", $val)) 
     91            foreach($val['attributes'] as $key2 => $val2) 
     92            { 
     93              $returned.="<br><span style='color:#".$color[$val['level']]."'>".str_repeat("&nbsp;", 5+3*$val['level'])."<i>[".$key2."] ".$val2."</i></span>"; 
     94            } 
     95          break; 
     96        case "close": 
     97          $returned.="<span style='color:#".$color[$val['level']]."'>(".$val['level'].")".str_repeat("&nbsp;", 3*$val['level'])."/".$val['tag']."</span>"; 
     98          if(array_key_exists("attributes", $val)) 
     99            foreach($val['attributes'] as $key2 => $val2) 
     100            { 
     101              $returned.="<br><span style='color:#".$color[$val['level']]."'>".str_repeat("&nbsp;", 5+3*$val['level'])."<i>[".$key2."] ".$val2."</i></span>"; 
     102            } 
     103          break; 
     104        case "complete": 
     105          $returned.="<span style='color:#".$color[$val['level']]."'>(".$val['level'].")".str_repeat("&nbsp;", 3*$val['level'])."/".$val['tag']."</span>"; 
     106          if(array_key_exists("attributes", $val)) 
     107            foreach($val['attributes'] as $key2 => $val2) 
     108            { 
     109              $returned.="<br><span style='color:#".$color[$val['level']]."'>".str_repeat("&nbsp;", 5+3*$val['level'])."<i>[".$key2."] ".$val2."</i></span>"; 
     110            } 
     111          break; 
     112      } 
     113      if(array_key_exists('value', $val)) 
     114       $returned.=" <span style='color:#ff00ff;'>".$val['value']."</span>"; 
     115      $returned.="<br>"; 
     116 
     117    } 
     118 
     119    return($returned); 
     120  } 
     121 
     122 
     123  function dump_ifd($key2, $val2) 
     124  { 
     125    $returned=sprintf("IFD %02d: ", $key2).$val2->toString()."<br>"; 
     126 
     127    foreach($val2->getTags() as $key3 => $val3) 
     128    { 
     129      $returned.=dump_tag($key3, $val3->getTag(), "<span style='color:#804080;'>".sprintf("[%02d] ", $key3).$val3->toString()."</span><br>"); 
     130 
     131      if($val3->getTag()->getLabel() instanceof IfdReader) 
     132      { 
     133        $returned.="<div style='padding:1px;margin-bottom:2px;margin-right:4px;margin-left:25px;border:1px dotted #6060FF;'>"; 
     134        $returned.=dump_ifd($key3, $val3->getTag()->getLabel()); 
     135        $returned.="</div>"; 
     136      } 
     137    } 
     138    return($returned); 
     139  } 
     140 
     141 
     142  function dump_xmp($key2, $val2) 
     143  { 
     144    if(is_string($val2->getValue())) 
     145      $extra=$val2->getValue(); 
     146    elseif(is_array($val2->getValue())) 
     147      $extra=print_r($val2->getValue(), true); 
     148    else 
     149      $extra=ConvertData::toHexDump($val2->getValue(), ByteType::ASCII); 
     150 
     151    $extra="<br><span style='color:#000000;'>".$extra."</span><br>"; 
     152 
     153    $returned="<div style='color:#000000;margin-left:12px;border-bottom:1px solid #808080;"; 
     154    if(!$val2->isKnown()) 
     155    { 
     156      $returned.="background:#ffd0d0;'>"; 
     157    } 
     158    elseif(!$val2->isImplemented()) 
     159    { 
     160      $returned.="background:#ffffd0;'>"; 
     161    } 
     162    else 
     163    { 
     164      $returned.="background:#d0ffd0;'>"; 
     165      $extra=""; 
     166    } 
     167 
     168    $returned.="<span style='color:#804080;'>".$val2->toString().$extra."</span></div>"; 
     169 
     170    return($returned); 
     171  } 
     172 
     173 
     174  function dump_tag($key3, $val3, $extra) 
     175  { 
     176    $returned="<div style='color:#000000;margin-left:12px;border-bottom:1px solid #808080;"; 
     177    if(!$val3->isKnown()) 
     178    { 
     179      $returned.="background:#ffd0d0;'>".$extra; 
     180    } 
     181    elseif(!$val3->isImplemented()) 
     182    { 
     183      $returned.="background:#ffffd0;'>".$extra; 
     184    } 
     185    else 
     186    { 
     187      $returned.="background:#d0ffd0;'>"; 
     188    } 
     189 
     190    $returned.=str_replace(" ", "&nbsp;", "     ").$val3->toString("small")."<br></div>"; 
     191 
     192    return($returned); 
     193  } 
     194 
     195  /* 
     196  function cmp($a, $b) 
     197  { 
     198      if ($a['value'] == $b['value']) { 
     199          return 0; 
     200      } 
     201      return ($a['value'] < $b['value']) ? -1 : 1; 
     202  } 
     203 
     204  function list_for_po() 
     205  { 
     206 
     207    $tmpTagName=Array(); 
     208    $tmpValues=Array(); 
     209 
     210    $tagList=Array( 
     211      new IfdTags(), 
     212      new XmpTags(), 
     213      new IptcTags(), 
     214      new GpsTags(), 
     215      new PentaxTags(), 
     216    ); 
     217 
     218 
     219    foreach($tagList as $key => $tag) 
     220    { 
     221 
     222      foreach($tag->getTags() as $key => $val) 
     223      { 
     224        if(array_key_exists('tagName', $val)) 
     225          $name=$val['tagName']; 
     226        else 
     227          $name=""; 
     228 
     229        if(is_string($key)) 
     230          $tKey=$key; 
     231        else 
     232          $tKey=sprintf("0x%04x", $key); 
     233 
     234        if($name!="") 
     235          $tKey.=" ($name)"; 
     236 
     237        if($name!="") 
     238        { 
     239          $tmpTagName[]=Array('group' => $tag->getLabel()." / ".$tKey, 'value' => $name); 
     240        } 
     241        else 
     242        { 
     243          $tmpTagName[]=Array('group' => $tag->getLabel()." / ".$tKey, 'value' => $key); 
     244        } 
     245 
     246        if(array_key_exists('tagValues', $val) and $val['translatable']) 
     247        { 
     248          foreach($val['tagValues'] as $key2 => $val2) 
    66249          { 
    67             echo "<br><span style='color:#".$color[$val['level']]."'>".str_repeat("&nbsp;", 5+3*$val['level'])."<i>[".$key2."] ".$val2."</i></span>"; 
     250            $tmpValues[]=Array('group' => $tag->getLabel()." / ".$tKey, 'value' => $val2); 
    68251          } 
    69         break; 
    70       case "close": 
    71         echo "<span style='color:#".$color[$val['level']]."'>(".$val['level'].")".str_repeat("&nbsp;", 3*$val['level'])."/".$val['tag']."</span>"; 
    72         if(array_key_exists("attributes", $val)) 
    73           foreach($val['attributes'] as $key2 => $val2) 
     252        } 
     253 
     254        if(array_key_exists('tagValues.special', $val) and $val['translatable']) 
     255        { 
     256          foreach($val['tagValues.special'] as $key2 => $val2) 
    74257          { 
    75             echo "<br><span style='color:#".$color[$val['level']]."'>".str_repeat("&nbsp;", 5+3*$val['level'])."<i>[".$key2."] ".$val2."</i></span>"; 
     258            $tmpValues[]=Array('group' => $tag->getLabel()." / ".$tKey, 'value' => $val2); 
    76259          } 
    77         break; 
    78       case "complete": 
    79         echo "<span style='color:#".$color[$val['level']]."'>(".$val['level'].")".str_repeat("&nbsp;", 3*$val['level'])."/".$val['tag']."</span>"; 
    80         if(array_key_exists("attributes", $val)) 
    81           foreach($val['attributes'] as $key2 => $val2) 
     260        } 
     261 
     262        if(array_key_exists('tagValues.specialNames', $val) and $val['translatable']) 
     263        { 
     264          foreach($val['tagValues.specialNames'] as $key2 => $val2) 
    82265          { 
    83             echo "<br><span style='color:#".$color[$val['level']]."'>".str_repeat("&nbsp;", 5+3*$val['level'])."<i>[".$key2."] ".$val2."</i></span>"; 
     266            $tmpValues[]=Array('group' => $tag->getLabel()." / ".$tKey, 'value' => $val2); 
    84267          } 
    85         break; 
    86     } 
    87     if(array_key_exists('value', $val)) 
    88      echo " <span style='color:#ff00ff;'>".$val['value']."</span>"; 
    89     echo "<br>"; 
    90  
    91   } 
    92  
    93   $tmp=new XmlData($xml); 
    94  
    95   //echo "has node:".($tmp->hasNodes()?"Y":"N")."<br>"; 
    96  
    97   dump_node($tmp->getFirstNode()); 
    98  
    99  
    100 } 
    101  
    102 function dump_node($node) 
    103 { 
    104   if($node==NULL) 
    105     return(false); 
    106   //echo "name:".$node->getName()." / level:".$node->getLevel()." / attributes: ".count($node->getAttributes())." / has child:".($node->hasChilds()?"Y":"N")."<br>"; 
    107  
    108   if($node->hasChilds()) 
    109   { 
    110     dump_node($node->getFirstChild()); 
    111   } 
    112  
    113   dump_node($node->getNextNode()); 
    114 } 
    115  
    116 function dump_ifd($key2, $val2) 
    117 { 
    118   echo sprintf("IFD %02d: ", $key2).$val2->toString()."<br>"; 
    119  
    120   foreach($val2->getTags() as $key3 => $val3) 
    121   { 
    122     dump_tag($key3, $val3->getTag(), "<span style='color:#804080;'>".sprintf("[%02d] ", $key3).$val3->toString()."</span><br>"); 
    123  
    124     /* 
    125     if($val3->isOffset()) 
    126     { 
    127       echo "<div style='color:#ff0000;margin-left:40px;'>"; 
    128       echo ConvertData::toHexDump($val3->getValue(), $val3->getType(),15)." => ".substr($val3->getValue(),0,254)."<br>"; 
    129       echo "</div>"; 
    130     } 
    131     */ 
    132  
    133     if($val3->getTag()->getLabel() instanceof IfdReader) 
    134     { 
    135       echo "<div style='padding:1px;margin-bottom:2px;margin-right:4px;margin-left:25px;border:1px dotted #6060FF;'>"; 
    136       dump_ifd($key3, $val3->getTag()->getLabel()); 
    137       echo "</div>"; 
    138     } 
    139   } 
    140 } 
    141  
    142 function dump_xmp($key2, $val2) 
    143 { 
    144   if(is_string($val2->getValue())) 
    145     $extra=$val2->getValue(); 
    146   elseif(is_array($val2->getValue())) 
    147     $extra=print_r($val2->getValue(), true); 
     268        } 
     269 
     270        if(array_key_exists('tagValues.specialValues', $val) and $val['translatable']) 
     271        { 
     272          foreach($val['tagValues.specialValues'] as $key2 => $val2) 
     273          { 
     274            $tmpValues[]=Array('group' => $tag->getLabel()." / ".$tKey, 'value' => $val2); 
     275          } 
     276        } 
     277 
     278        if(array_key_exists('tagValues.computed', $val) and $val['translatable']) 
     279        { 
     280          foreach($val['tagValues.computed'] as $key2 => $val2) 
     281          { 
     282            $tmpValues[]=Array('group' => $tag->getLabel()." / ".$tKey, 'value' => $val2); 
     283          } 
     284        } 
     285 
     286 
     287      } 
     288 
     289    } 
     290 
     291    $tmp=array_merge($tmpTagName, $tmpValues); 
     292    usort($tmp, "cmp"); 
     293 
     294    foreach($tmp as $key => $val) 
     295    { 
     296      echo "#. ".$val['group']."<br>"; 
     297      echo "msgid \"".$val['value']."\"<br>"; 
     298      echo "msgstr \"".$val['value']."\"<br><br>"; 
     299    } 
     300 
     301  } 
     302  */ 
     303 
     304 
     305  $page="<html><header><meta http-equiv='Content-Type' content='text/html; charset=utf-8' /></header><body>"; 
     306 
     307 
     308  $page.="<hr>-- Images --<br>"; 
     309 
     310  /* 
     311   * display a list of jpeg files in the current directory 
     312   */ 
     313  $directory = scandir(dirname(__FILE__)); 
     314 
     315  foreach($directory as $key => $file) 
     316  { 
     317    if(preg_match("/.*\.(jpg|jpeg)/i",$file)) 
     318      $page.="[<a href='?file=".$file."'>$file</a>]&nbsp; "; 
     319  } 
     320 
     321 
     322  $page.="<hr>-- Resultat --<br>"; 
     323 
     324 
     325  if(isset($_GET["file"])) 
     326  { 
     327    $file=$_GET["file"]; 
     328  } 
    148329  else 
    149     $extra=ConvertData::toHexDump($val2->getValue(), ByteType::ASCII); 
    150  
    151   $extra="<br><span style='color:#000000;'>".$extra."</span><br>"; 
    152  
    153   echo "<div style='color:#000000;margin-left:12px;border-bottom:1px solid #808080;"; 
    154   if(!$val2->getIsKnown()) 
    155   { 
    156     echo "background:#ffd0d0;'>"; 
    157   } 
    158   elseif(!$val2->getIsImplemented()) 
    159   { 
    160     echo "background:#ffffd0;'>"; 
    161   } 
    162   else 
    163   { 
    164     echo "background:#d0ffd0;'>"; 
    165     $extra=""; 
    166   } 
    167  
    168   echo "<span style='color:#804080;'>".$val2->toString().$extra; 
    169  /* if($val2->getName()!=$val2->getId()) 
    170     echo " ==> Id: ".$val2->getId();*/ 
    171   echo "</span>"; 
    172  
    173   echo "</div>"; 
    174 } 
    175  
    176 function dump_tag($key3, $val3, $extra) 
    177 { 
    178     echo "<div style='color:#000000;margin-left:12px;border-bottom:1px solid #808080;"; 
    179     if(!$val3->getIsKnown()) 
    180     { 
    181       echo "background:#ffd0d0;'>".$extra; 
    182     } 
    183     elseif(!$val3->getIsImplemented()) 
    184     { 
    185       echo "background:#ffffd0;'>".$extra; 
    186     } 
    187     else 
    188     { 
    189       echo "background:#d0ffd0;'>"; 
    190     } 
    191  
    192     echo str_replace(" ", "&nbsp;", "     ").$val3->toString("small")."<br>"; 
    193  
    194     echo "</div>"; 
    195 } 
    196  
    197 /* 
    198 function cmp($a, $b) 
    199 { 
    200     if ($a['value'] == $b['value']) { 
    201         return 0; 
    202     } 
    203     return ($a['value'] < $b['value']) ? -1 : 1; 
    204 } 
    205  
    206 function list_for_po() 
    207 { 
    208  
    209   $tmpTagName=Array(); 
    210   $tmpValues=Array(); 
    211  
    212   $tagList=Array( 
    213     new IfdTags(), 
    214     new XmpTags(), 
    215     new IptcTags(), 
    216     new GpsTags(), 
    217     new PentaxTags(), 
    218   ); 
    219  
    220  
    221   foreach($tagList as $key => $tag) 
    222   { 
    223  
    224     foreach($tag->getTags() as $key => $val) 
    225     { 
    226       if(array_key_exists('tagName', $val)) 
    227         $name=$val['tagName']; 
    228       else 
    229         $name=""; 
    230  
    231       if(is_string($key)) 
    232         $tKey=$key; 
    233       else 
    234         $tKey=sprintf("0x%04x", $key); 
    235  
    236       if($name!="") 
    237         $tKey.=" ($name)"; 
    238  
    239       if($name!="") 
    240       { 
    241         $tmpTagName[]=Array('group' => $tag->getLabel()." / ".$tKey, 'value' => $name); 
    242       } 
    243       else 
    244       { 
    245         $tmpTagName[]=Array('group' => $tag->getLabel()." / ".$tKey, 'value' => $key); 
    246       } 
    247  
    248       if(array_key_exists('tagValues', $val) and $val['translatable']) 
    249       { 
    250         foreach($val['tagValues'] as $key2 => $val2) 
    251         { 
    252           $tmpValues[]=Array('group' => $tag->getLabel()." / ".$tKey, 'value' => $val2); 
    253         } 
    254       } 
    255  
    256       if(array_key_exists('tagValues.special', $val) and $val['translatable']) 
    257       { 
    258         foreach($val['tagValues.special'] as $key2 => $val2) 
    259         { 
    260           $tmpValues[]=Array('group' => $tag->getLabel()." / ".$tKey, 'value' => $val2); 
    261         } 
    262       } 
    263  
    264       if(array_key_exists('tagValues.specialNames', $val) and $val['translatable']) 
    265       { 
    266         foreach($val['tagValues.specialNames'] as $key2 => $val2) 
    267         { 
    268           $tmpValues[]=Array('group' => $tag->getLabel()." / ".$tKey, 'value' => $val2); 
    269         } 
    270       } 
    271  
    272       if(array_key_exists('tagValues.specialValues', $val) and $val['translatable']) 
    273       { 
    274         foreach($val['tagValues.specialValues'] as $key2 => $val2) 
    275         { 
    276           $tmpValues[]=Array('group' => $tag->getLabel()." / ".$tKey, 'value' => $val2); 
    277         } 
    278       } 
    279  
    280       if(array_key_exists('tagValues.computed', $val) and $val['translatable']) 
    281       { 
    282         foreach($val['tagValues.computed'] as $key2 => $val2) 
    283         { 
    284           $tmpValues[]=Array('group' => $tag->getLabel()." / ".$tKey, 'value' => $val2); 
    285         } 
    286       } 
    287  
    288  
    289     } 
    290  
    291   } 
    292  
    293   $tmp=array_merge($tmpTagName, $tmpValues); 
    294   usort($tmp, "cmp"); 
    295  
    296   foreach($tmp as $key => $val) 
    297   { 
    298     echo "#. ".$val['group']."<br>"; 
    299     echo "msgid \"".$val['value']."\"<br>"; 
    300     echo "msgstr \"".$val['value']."\"<br><br>"; 
    301   } 
    302  
    303 } 
    304 */ 
    305  
    306   if(isset($_GET["file"])) 
    307   { 
    308     $file=$_GET["file"]; 
    309   } 
    310   else 
    311   { 
    312     die("no filename ?<br/></body></html>"); 
    313   } 
     330  { 
     331    $page.="no filename ?<br/></body></html>"; 
     332    die($page); 
     333  } 
     334 
     335  $page.="<span style='font-family:monospace;'>"; 
    314336 
    315337  $memory=memory_get_usage(); 
    316   echo "memory : ".$memory."<br>"; 
     338  $time=microtime(true); 
    317339 
    318340  $jpeg = new JpegReader($file); 
    319   echo "<span style='font-family:monospace;'>JpegReader<br>"; 
    320   echo "fileName=".$jpeg->getFileName()."<br>"; 
    321   echo "isValid=".($jpeg->isValid()?"Y":"N")."<br>"; 
    322   echo "isLoaded=".($jpeg->isLoaded()?"Y":"N")."<br>"; 
    323   echo "NbMarkers=".$jpeg->countAppMarkerSegments()."<br>"; 
     341  $time2=microtime(true); 
     342 
     343  $page2="JpegReader extraction<br>"; 
     344  $page2.="fileName=".$jpeg->getFileName()."<br>"; 
     345  $page2.="isValid=".($jpeg->isValid()?"Y":"N")."<br>"; 
     346  $page2.="isLoaded=".($jpeg->isLoaded()?"Y":"N")."<br>"; 
     347  $page2.="NbMarkers=".$jpeg->countAppMarkerSegments()."<br>"; 
     348 
    324349  foreach($jpeg->getAppMarkerSegments() as $key => $val) 
    325350  { 
    326     echo "<div style='border:1px solid #000000;padding:4px;margin:1px;'>"; 
    327     echo sprintf("[%02d] ", $key).$val->toString()."<br>"; 
     351    $page2.="<div style='border:1px solid #000000;padding:4px;margin:1px;'>"; 
     352    $page2.=sprintf("[%02d] ", $key).$val->toString()."<br>"; 
    328353    if($val->dataLoaded()) 
    329354    { 
    330       echo "<div style='color:#0000ff;font-weight:bold;margin-left:20px;'>"; 
     355      $page2.="<div style='color:#0000ff;font-weight:bold;margin-left:20px;'>"; 
    331356      $data=$val->getData(); 
    332357      if($data instanceof TiffReader) 
    333358      { 
    334         echo $data->toString()."<br>"; 
     359        $page2.=$data->toString()."<br>"; 
    335360 
    336361        foreach($data->getIFDs() as $key2 => $val2) 
    337362        { 
    338           echo "<div style='color:#0000ff;font-weight:normal;margin-left:12px;'>"; 
    339  
    340           dump_ifd($key2, $val2); 
    341  
    342           echo "</div>"; 
    343         } 
    344  
     363          $page2.="<div style='color:#0000ff;font-weight:normal;margin-left:12px;'>"; 
     364          $page2.=dump_ifd($key2, $val2); 
     365          $page2.="</div>"; 
     366        } 
    345367      } 
    346368      elseif($data instanceof XmpReader) 
    347369      { 
    348         echo htmlentities($data->toString())."<br>"; 
    349         echo dump_xml($data->toString())."<br>"; 
     370        $page2.=htmlentities($data->toString())."<br>"; 
     371        $page2.=dump_xml($data->toString())."<br>"; 
    350372 
    351373        foreach($data->getTags() as $key2 => $val2) 
    352374        { 
    353           echo "<div style='color:#0000ff;font-weight:normal;margin-left:12px;'>"; 
    354  
    355           dump_xmp($key2, $val2); 
    356  
    357           echo "</div>"; 
    358         } 
    359  
    360  
     375          $page2.="<div style='color:#0000ff;font-weight:normal;margin-left:12px;'>"; 
     376          $page2.=dump_xmp($key2, $val2); 
     377          $page2.="</div>"; 
     378        } 
    361379      } 
    362380      elseif($data instanceof IptcReader) 
     
    365383        foreach($data->getTags() as $key2 => $val2) 
    366384        { 
    367           echo "<div style='color:#0000ff;font-weight:normal;margin-left:12px;'>"; 
    368  
    369           dump_tag($key2, $val2, ""); 
    370  
    371           echo "</div>"; 
    372         } 
    373  
    374  
     385          $page2.="<div style='color:#0000ff;font-weight:normal;margin-left:12px;'>"; 
     386          $page2.=dump_tag($key2, $val2, ""); 
     387          $page2.="</div>"; 
     388        } 
    375389      } 
    376390      else 
    377391      { 
    378        echo htmlentities($val->getData())."<br>"; 
    379       } 
    380       echo "</div>"; 
    381     } 
    382     echo "</div>"; 
    383  
    384   } 
    385   echo "</span><hr>"; 
    386  
    387  
    388   Locale::set("en_UK"); 
    389  
    390   echo "<span style='font-family:monospace;'>JpegMetaData - tag from test file<br>"; 
    391   echo "<table style='border:1px solid #000000;'>"; 
    392   echo "<tr style='border-bottom:1x solid #000000;'><th>Key</th><th>Name</th><th>Value</th><th>Computed Value</th></tr>"; 
     392       $page2.=htmlentities($val->getData())."<br>"; 
     393      } 
     394      $page2.="</div>"; 
     395    } 
     396    $page2.="</div>"; 
     397  } 
     398  $page2.="</span><hr>"; 
     399 
     400  $page2.="<div style='font-family:monospace;'>JpegMetaData - tag from test file<br>"; 
     401  $page2.="<table style='border:1px solid #000000;width:100%;'>"; 
     402  $page2.="<tr style='border-bottom:1x solid #000000;'><th>Key</th><th>Name</th><th>Value</th><th>Computed Value</th></tr>"; 
     403 
    393404  $jpegmd = new JpegMetaData($file, Array( 
    394405    'filter' => JpegMetaData::TAGFILTER_IMPLEMENTED, 
     
    402413    $value=$val->getValue(); 
    403414 
    404     if($val->getIsTranslatable()) 
     415    if($val->isTranslatable()) 
    405416      $style="color:#0000ff"; 
    406417    else 
    407418      $style="color:#000000"; 
    408419 
    409     if(is_string($txt) and $val->getIsTranslatable()) 
     420    if(is_string($txt) and $val->isTranslatable()) 
    410421      $txt=Locale::get($txt); 
    411422    if($txt instanceof DateTime) 
     
    415426    if(is_array($value)) 
    416427      $value=print_r($value, true); 
    417     echo "<tr><td>".$key."</td><td>".Locale::get($val->getName())."</td><td>".$value."</td><td style='$style'>".$txt."</td></tr>"; 
     428    $page2.="<tr><td>".$key."</td><td>".Locale::get($val->getName())."</td><td>".$value."</td><td style='$style'>".$txt."</td></tr>"; 
    418429    $i++; 
    419430  } 
    420   echo "</table>Total tags: $i</span><hr>"; 
     431  $page2.="</table>Total tags: $i</div><hr>"; 
     432 
    421433 
    422434  $i=0; 
    423435  $j=0; 
    424   echo "<span style='font-family:monospace;'>JpegMetaData - known tags<br>"; 
    425   echo "<table style='border:1px solid #000000;'>"; 
    426   echo "<tr style='border-bottom:1x solid #000000;'><th>Key</th><th>Name</th><th>Implemented</th></tr>"; 
    427   foreach($jpegmd->getTagList(Array('filter' => JpegMetaData::TAGFILTER_ALL, 'xmp' => true, 'maker' => true, 'iptc' => true)) as $key => $val) 
     436  $page2.="<div style='font-family:monospace;'>JpegMetaData - known tags<br>"; 
     437  $page2.="<table style='border:1px solid #000000;width:100%;'>"; 
     438  $page2.="<tr style='border-bottom:1x solid #000000;'><th>Key</th><th>Name</th><th>Implemented</th></tr>"; 
     439  foreach(JpegMetaData::getTagList(Array('filter' => JpegMetaData::TAGFILTER_ALL, 'xmp' => true, 'maker' => true, 'iptc' => true)) as $key => $val) 
    428440  { 
    429441    $val['implemented']?$i++:$j++; 
    430     echo "<tr><td>".$key."</td><td>".Locale::get($val['name'])."</td><td>".($val['implemented']?"yes":"no")."</td></tr>"; 
    431   } 
    432   echo "</table>Total tags ; implemented: $i - not implemented: $j</span><hr>"; 
     442    $page2.="<tr><td>".$key."</td><td>".Locale::get($val['name'])."</td><td>".($val['implemented']?"yes":"no")."</td></tr>"; 
     443  } 
     444  $page2.="</table>Total tags ; implemented: $i - not implemented: $j</span><hr>"; 
    433445 
    434446  unset($jpegmd); 
    435447  unset($jpeg); 
    436448  $memory2=memory_get_usage(); 
    437   echo "memory : ".$memory2." (memory leak ? = ".($memory2-$memory).")<br>"; 
    438   echo "<br/></body></html>"; 
     449  $page.="parsing time : ".($time2-$time)."<br>"; 
     450  $page.="memory on start : ".$memory."<br>"; 
     451  $page.="memory on end : ".$memory2." (memory leak ? = ".($memory2-$memory).")<br><br>"; 
     452 
     453  $page.=$page2; 
     454  $page.="<br/></body></html>"; 
     455 
     456  echo $page; 
    439457?> 
Note: See TracChangeset for help on using the changeset viewer.